home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Utilities / uae-0.4 / Source Code / CPU Sources / cpu0.c next >
C/C++ Source or Header  |  1996-02-13  |  77KB  |  2,966 lines
  1. #include "config.h"
  2. #include "amiga.h"
  3. #include "options.h"
  4. #include <stdlib.h>
  5. #include "memory.h"
  6. #include "custom.h"
  7. #include "newcpu.h"
  8. #include "cputbl.h"
  9.  
  10. void op_0(UWORD opcode)
  11. {
  12.     ULONG dstreg = (opcode & 7) >> 0;
  13. {{    BYTE src = nextiword();
  14. {    BYTE dst = regs.d[dstreg];
  15.     src |= dst;
  16.     regs.v = regs.c = 0;
  17.     regs.z = ((BYTE)(src)) == 0;
  18.     regs.n = ((BYTE)(src)) < 0;
  19.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  20. }}}}
  21. void op_10(UWORD opcode)
  22. {
  23.     ULONG dstreg = (opcode & 7) >> 0;
  24. {{    BYTE src = nextiword();
  25. {    CPTR dsta = regs.a[dstreg];
  26.     BYTE dst = get_byte(dsta);
  27.     src |= dst;
  28.     regs.v = regs.c = 0;
  29.     regs.z = ((BYTE)(src)) == 0;
  30.     regs.n = ((BYTE)(src)) < 0;
  31.     put_byte(dsta,src);
  32. }}}}
  33. void op_18(UWORD opcode)
  34. {
  35.     ULONG dstreg = (opcode & 7) >> 0;
  36. {{    BYTE src = nextiword();
  37. {    CPTR dsta = regs.a[dstreg];
  38.     BYTE dst = get_byte(dsta);
  39. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  40.     src |= dst;
  41.     regs.v = regs.c = 0;
  42.     regs.z = ((BYTE)(src)) == 0;
  43.     regs.n = ((BYTE)(src)) < 0;
  44.     put_byte(dsta,src);
  45. }}}}}
  46. void op_20(UWORD opcode)
  47. {
  48.     ULONG dstreg = (opcode & 7) >> 0;
  49. {{    BYTE src = nextiword();
  50. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  51. {    CPTR dsta = regs.a[dstreg];
  52.     BYTE dst = get_byte(dsta);
  53.     src |= dst;
  54.     regs.v = regs.c = 0;
  55.     regs.z = ((BYTE)(src)) == 0;
  56.     regs.n = ((BYTE)(src)) < 0;
  57.     put_byte(dsta,src);
  58. }}}}}
  59. void op_28(UWORD opcode)
  60. {
  61.     ULONG dstreg = (opcode & 7) >> 0;
  62. {{    BYTE src = nextiword();
  63. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  64.     BYTE dst = get_byte(dsta);
  65.     src |= dst;
  66.     regs.v = regs.c = 0;
  67.     regs.z = ((BYTE)(src)) == 0;
  68.     regs.n = ((BYTE)(src)) < 0;
  69.     put_byte(dsta,src);
  70. }}}}
  71. void op_30(UWORD opcode)
  72. {
  73.     ULONG dstreg = (opcode & 7) >> 0;
  74. {{    BYTE src = nextiword();
  75. {    CPTR dsta = regs.a[dstreg];
  76.     UWORD dstdp = nextiword();
  77.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  78. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  79.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  80.     dsta += dstdpr;
  81. {    BYTE dst = get_byte(dsta);
  82.     src |= dst;
  83.     regs.v = regs.c = 0;
  84.     regs.z = ((BYTE)(src)) == 0;
  85.     regs.n = ((BYTE)(src)) < 0;
  86.     put_byte(dsta,src);
  87. }}}}}}
  88. void op_38(UWORD opcode)
  89. {
  90. {{    BYTE src = nextiword();
  91. {    CPTR dsta = (LONG)(WORD)nextiword();
  92.     BYTE dst = get_byte(dsta);
  93.     src |= dst;
  94.     regs.v = regs.c = 0;
  95.     regs.z = ((BYTE)(src)) == 0;
  96.     regs.n = ((BYTE)(src)) < 0;
  97.     put_byte(dsta,src);
  98. }}}}
  99. void op_39(UWORD opcode)
  100. {
  101. {{    BYTE src = nextiword();
  102. {    CPTR dsta = nextilong();
  103.     BYTE dst = get_byte(dsta);
  104.     src |= dst;
  105.     regs.v = regs.c = 0;
  106.     regs.z = ((BYTE)(src)) == 0;
  107.     regs.n = ((BYTE)(src)) < 0;
  108.     put_byte(dsta,src);
  109. }}}}
  110. void op_3c(UWORD opcode)
  111. {
  112. {{    MakeSR();
  113. {    WORD src = nextiword();
  114.     src &= 0xFF;
  115.     regs.sr |= src;
  116.     MakeFromSR();
  117. }}}}
  118. void op_40(UWORD opcode)
  119. {
  120.     ULONG dstreg = (opcode & 7) >> 0;
  121. {{    WORD src = nextiword();
  122. {    WORD dst = regs.d[dstreg];
  123.     src |= dst;
  124.     regs.v = regs.c = 0;
  125.     regs.z = ((WORD)(src)) == 0;
  126.     regs.n = ((WORD)(src)) < 0;
  127.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  128. }}}}
  129. void op_50(UWORD opcode)
  130. {
  131.     ULONG dstreg = (opcode & 7) >> 0;
  132. {{    WORD src = nextiword();
  133. {    CPTR dsta = regs.a[dstreg];
  134.     WORD dst = get_word(dsta);
  135.     src |= dst;
  136.     regs.v = regs.c = 0;
  137.     regs.z = ((WORD)(src)) == 0;
  138.     regs.n = ((WORD)(src)) < 0;
  139.     put_word(dsta,src);
  140. }}}}
  141. void op_58(UWORD opcode)
  142. {
  143.     ULONG dstreg = (opcode & 7) >> 0;
  144. {{    WORD src = nextiword();
  145. {    CPTR dsta = regs.a[dstreg];
  146.     WORD dst = get_word(dsta);
  147. {    regs.a[dstreg] += 2;
  148.     src |= dst;
  149.     regs.v = regs.c = 0;
  150.     regs.z = ((WORD)(src)) == 0;
  151.     regs.n = ((WORD)(src)) < 0;
  152.     put_word(dsta,src);
  153. }}}}}
  154. void op_60(UWORD opcode)
  155. {
  156.     ULONG dstreg = (opcode & 7) >> 0;
  157. {{    WORD src = nextiword();
  158. {    regs.a[dstreg] -= 2;
  159. {    CPTR dsta = regs.a[dstreg];
  160.     WORD dst = get_word(dsta);
  161.     src |= dst;
  162.     regs.v = regs.c = 0;
  163.     regs.z = ((WORD)(src)) == 0;
  164.     regs.n = ((WORD)(src)) < 0;
  165.     put_word(dsta,src);
  166. }}}}}
  167. void op_68(UWORD opcode)
  168. {
  169.     ULONG dstreg = (opcode & 7) >> 0;
  170. {{    WORD src = nextiword();
  171. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  172.     WORD dst = get_word(dsta);
  173.     src |= dst;
  174.     regs.v = regs.c = 0;
  175.     regs.z = ((WORD)(src)) == 0;
  176.     regs.n = ((WORD)(src)) < 0;
  177.     put_word(dsta,src);
  178. }}}}
  179. void op_70(UWORD opcode)
  180. {
  181.     ULONG dstreg = (opcode & 7) >> 0;
  182. {{    WORD src = nextiword();
  183. {    CPTR dsta = regs.a[dstreg];
  184.     UWORD dstdp = nextiword();
  185.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  186. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  187.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  188.     dsta += dstdpr;
  189. {    WORD dst = get_word(dsta);
  190.     src |= dst;
  191.     regs.v = regs.c = 0;
  192.     regs.z = ((WORD)(src)) == 0;
  193.     regs.n = ((WORD)(src)) < 0;
  194.     put_word(dsta,src);
  195. }}}}}}
  196. void op_78(UWORD opcode)
  197. {
  198. {{    WORD src = nextiword();
  199. {    CPTR dsta = (LONG)(WORD)nextiword();
  200.     WORD dst = get_word(dsta);
  201.     src |= dst;
  202.     regs.v = regs.c = 0;
  203.     regs.z = ((WORD)(src)) == 0;
  204.     regs.n = ((WORD)(src)) < 0;
  205.     put_word(dsta,src);
  206. }}}}
  207. void op_79(UWORD opcode)
  208. {
  209. {{    WORD src = nextiword();
  210. {    CPTR dsta = nextilong();
  211.     WORD dst = get_word(dsta);
  212.     src |= dst;
  213.     regs.v = regs.c = 0;
  214.     regs.z = ((WORD)(src)) == 0;
  215.     regs.n = ((WORD)(src)) < 0;
  216.     put_word(dsta,src);
  217. }}}}
  218. void op_7c(UWORD opcode)
  219. {
  220. {    if (!regs.s) { regs.pc_p--; Exception(8); } else
  221. {    MakeSR();
  222. {    WORD src = nextiword();
  223.     regs.sr |= src;
  224.     MakeFromSR();
  225. }}}}
  226. void op_80(UWORD opcode)
  227. {
  228.     ULONG dstreg = (opcode & 7) >> 0;
  229. {{    LONG src = nextilong();
  230. {    LONG dst = regs.d[dstreg];
  231.     src |= dst;
  232.     regs.v = regs.c = 0;
  233.     regs.z = ((LONG)(src)) == 0;
  234.     regs.n = ((LONG)(src)) < 0;
  235.     regs.d[dstreg] = (src);
  236. }}}}
  237. void op_90(UWORD opcode)
  238. {
  239.     ULONG dstreg = (opcode & 7) >> 0;
  240. {{    LONG src = nextilong();
  241. {    CPTR dsta = regs.a[dstreg];
  242.     LONG dst = get_long(dsta);
  243.     src |= dst;
  244.     regs.v = regs.c = 0;
  245.     regs.z = ((LONG)(src)) == 0;
  246.     regs.n = ((LONG)(src)) < 0;
  247.     put_long(dsta,src);
  248. }}}}
  249. void op_98(UWORD opcode)
  250. {
  251.     ULONG dstreg = (opcode & 7) >> 0;
  252. {{    LONG src = nextilong();
  253. {    CPTR dsta = regs.a[dstreg];
  254.     LONG dst = get_long(dsta);
  255. {    regs.a[dstreg] += 4;
  256.     src |= dst;
  257.     regs.v = regs.c = 0;
  258.     regs.z = ((LONG)(src)) == 0;
  259.     regs.n = ((LONG)(src)) < 0;
  260.     put_long(dsta,src);
  261. }}}}}
  262. void op_a0(UWORD opcode)
  263. {
  264.     ULONG dstreg = (opcode & 7) >> 0;
  265. {{    LONG src = nextilong();
  266. {    regs.a[dstreg] -= 4;
  267. {    CPTR dsta = regs.a[dstreg];
  268.     LONG dst = get_long(dsta);
  269.     src |= dst;
  270.     regs.v = regs.c = 0;
  271.     regs.z = ((LONG)(src)) == 0;
  272.     regs.n = ((LONG)(src)) < 0;
  273.     put_long(dsta,src);
  274. }}}}}
  275. void op_a8(UWORD opcode)
  276. {
  277.     ULONG dstreg = (opcode & 7) >> 0;
  278. {{    LONG src = nextilong();
  279. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  280.     LONG dst = get_long(dsta);
  281.     src |= dst;
  282.     regs.v = regs.c = 0;
  283.     regs.z = ((LONG)(src)) == 0;
  284.     regs.n = ((LONG)(src)) < 0;
  285.     put_long(dsta,src);
  286. }}}}
  287. void op_b0(UWORD opcode)
  288. {
  289.     ULONG dstreg = (opcode & 7) >> 0;
  290. {{    LONG src = nextilong();
  291. {    CPTR dsta = regs.a[dstreg];
  292.     UWORD dstdp = nextiword();
  293.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  294. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  295.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  296.     dsta += dstdpr;
  297. {    LONG dst = get_long(dsta);
  298.     src |= dst;
  299.     regs.v = regs.c = 0;
  300.     regs.z = ((LONG)(src)) == 0;
  301.     regs.n = ((LONG)(src)) < 0;
  302.     put_long(dsta,src);
  303. }}}}}}
  304. void op_b8(UWORD opcode)
  305. {
  306. {{    LONG src = nextilong();
  307. {    CPTR dsta = (LONG)(WORD)nextiword();
  308.     LONG dst = get_long(dsta);
  309.     src |= dst;
  310.     regs.v = regs.c = 0;
  311.     regs.z = ((LONG)(src)) == 0;
  312.     regs.n = ((LONG)(src)) < 0;
  313.     put_long(dsta,src);
  314. }}}}
  315. void op_b9(UWORD opcode)
  316. {
  317. {{    LONG src = nextilong();
  318. {    CPTR dsta = nextilong();
  319.     LONG dst = get_long(dsta);
  320.     src |= dst;
  321.     regs.v = regs.c = 0;
  322.     regs.z = ((LONG)(src)) == 0;
  323.     regs.n = ((LONG)(src)) < 0;
  324.     put_long(dsta,src);
  325. }}}}
  326. void op_100(UWORD opcode)
  327. {
  328.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  329.     ULONG dstreg = (opcode & 7) >> 0;
  330. {{    LONG src = regs.d[srcreg];
  331. {    LONG dst = regs.d[dstreg];
  332.     src &= 31;
  333.     regs.z = !(dst & (1 << src));
  334. }}}}
  335. void op_110(UWORD opcode)
  336. {
  337.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  338.     ULONG dstreg = (opcode & 7) >> 0;
  339. {{    BYTE src = regs.d[srcreg];
  340. {    CPTR dsta = regs.a[dstreg];
  341.     BYTE dst = get_byte(dsta);
  342.     src &= 7;
  343.     regs.z = !(dst & (1 << src));
  344. }}}}
  345. void op_118(UWORD opcode)
  346. {
  347.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  348.     ULONG dstreg = (opcode & 7) >> 0;
  349. {{    BYTE src = regs.d[srcreg];
  350. {    CPTR dsta = regs.a[dstreg];
  351.     BYTE dst = get_byte(dsta);
  352. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  353.     src &= 7;
  354.     regs.z = !(dst & (1 << src));
  355. }}}}}
  356. void op_120(UWORD opcode)
  357. {
  358.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  359.     ULONG dstreg = (opcode & 7) >> 0;
  360. {{    BYTE src = regs.d[srcreg];
  361. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  362. {    CPTR dsta = regs.a[dstreg];
  363.     BYTE dst = get_byte(dsta);
  364.     src &= 7;
  365.     regs.z = !(dst & (1 << src));
  366. }}}}}
  367. void op_128(UWORD opcode)
  368. {
  369.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  370.     ULONG dstreg = (opcode & 7) >> 0;
  371. {{    BYTE src = regs.d[srcreg];
  372. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  373.     BYTE dst = get_byte(dsta);
  374.     src &= 7;
  375.     regs.z = !(dst & (1 << src));
  376. }}}}
  377. void op_130(UWORD opcode)
  378. {
  379.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  380.     ULONG dstreg = (opcode & 7) >> 0;
  381. {{    BYTE src = regs.d[srcreg];
  382. {    CPTR dsta = regs.a[dstreg];
  383.     UWORD dstdp = nextiword();
  384.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  385. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  386.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  387.     dsta += dstdpr;
  388. {    BYTE dst = get_byte(dsta);
  389.     src &= 7;
  390.     regs.z = !(dst & (1 << src));
  391. }}}}}}
  392. void op_138(UWORD opcode)
  393. {
  394.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  395. {{    BYTE src = regs.d[srcreg];
  396. {    CPTR dsta = (LONG)(WORD)nextiword();
  397.     BYTE dst = get_byte(dsta);
  398.     src &= 7;
  399.     regs.z = !(dst & (1 << src));
  400. }}}}
  401. void op_139(UWORD opcode)
  402. {
  403.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  404. {{    BYTE src = regs.d[srcreg];
  405. {    CPTR dsta = nextilong();
  406.     BYTE dst = get_byte(dsta);
  407.     src &= 7;
  408.     regs.z = !(dst & (1 << src));
  409. }}}}
  410. void op_140(UWORD opcode)
  411. {
  412.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  413.     ULONG dstreg = (opcode & 7) >> 0;
  414. {{    LONG src = regs.d[srcreg];
  415. {    LONG dst = regs.d[dstreg];
  416.     src &= 31;
  417.     regs.z = !(dst & (1 << src));
  418.     dst ^= (1 << src);
  419.     regs.d[dstreg] = (dst);
  420. }}}}
  421. void op_150(UWORD opcode)
  422. {
  423.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  424.     ULONG dstreg = (opcode & 7) >> 0;
  425. {{    BYTE src = regs.d[srcreg];
  426. {    CPTR dsta = regs.a[dstreg];
  427.     BYTE dst = get_byte(dsta);
  428.     src &= 7;
  429.     regs.z = !(dst & (1 << src));
  430.     dst ^= (1 << src);
  431.     put_byte(dsta,dst);
  432. }}}}
  433. void op_158(UWORD opcode)
  434. {
  435.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  436.     ULONG dstreg = (opcode & 7) >> 0;
  437. {{    BYTE src = regs.d[srcreg];
  438. {    CPTR dsta = regs.a[dstreg];
  439.     BYTE dst = get_byte(dsta);
  440. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  441.     src &= 7;
  442.     regs.z = !(dst & (1 << src));
  443.     dst ^= (1 << src);
  444.     put_byte(dsta,dst);
  445. }}}}}
  446. void op_160(UWORD opcode)
  447. {
  448.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  449.     ULONG dstreg = (opcode & 7) >> 0;
  450. {{    BYTE src = regs.d[srcreg];
  451. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  452. {    CPTR dsta = regs.a[dstreg];
  453.     BYTE dst = get_byte(dsta);
  454.     src &= 7;
  455.     regs.z = !(dst & (1 << src));
  456.     dst ^= (1 << src);
  457.     put_byte(dsta,dst);
  458. }}}}}
  459. void op_168(UWORD opcode)
  460. {
  461.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  462.     ULONG dstreg = (opcode & 7) >> 0;
  463. {{    BYTE src = regs.d[srcreg];
  464. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  465.     BYTE dst = get_byte(dsta);
  466.     src &= 7;
  467.     regs.z = !(dst & (1 << src));
  468.     dst ^= (1 << src);
  469.     put_byte(dsta,dst);
  470. }}}}
  471. void op_170(UWORD opcode)
  472. {
  473.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  474.     ULONG dstreg = (opcode & 7) >> 0;
  475. {{    BYTE src = regs.d[srcreg];
  476. {    CPTR dsta = regs.a[dstreg];
  477.     UWORD dstdp = nextiword();
  478.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  479. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  480.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  481.     dsta += dstdpr;
  482. {    BYTE dst = get_byte(dsta);
  483.     src &= 7;
  484.     regs.z = !(dst & (1 << src));
  485.     dst ^= (1 << src);
  486.     put_byte(dsta,dst);
  487. }}}}}}
  488. void op_178(UWORD opcode)
  489. {
  490.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  491. {{    BYTE src = regs.d[srcreg];
  492. {    CPTR dsta = (LONG)(WORD)nextiword();
  493.     BYTE dst = get_byte(dsta);
  494.     src &= 7;
  495.     regs.z = !(dst & (1 << src));
  496.     dst ^= (1 << src);
  497.     put_byte(dsta,dst);
  498. }}}}
  499. void op_179(UWORD opcode)
  500. {
  501.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  502. {{    BYTE src = regs.d[srcreg];
  503. {    CPTR dsta = nextilong();
  504.     BYTE dst = get_byte(dsta);
  505.     src &= 7;
  506.     regs.z = !(dst & (1 << src));
  507.     dst ^= (1 << src);
  508.     put_byte(dsta,dst);
  509. }}}}
  510. void op_180(UWORD opcode)
  511. {
  512.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  513.     ULONG dstreg = (opcode & 7) >> 0;
  514. {{    LONG src = regs.d[srcreg];
  515. {    LONG dst = regs.d[dstreg];
  516.     src &= 31;
  517.     regs.z = !(dst & (1 << src));
  518.     dst &= ~(1 << src);
  519.     regs.d[dstreg] = (dst);
  520. }}}}
  521. void op_190(UWORD opcode)
  522. {
  523.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  524.     ULONG dstreg = (opcode & 7) >> 0;
  525. {{    BYTE src = regs.d[srcreg];
  526. {    CPTR dsta = regs.a[dstreg];
  527.     BYTE dst = get_byte(dsta);
  528.     src &= 7;
  529.     regs.z = !(dst & (1 << src));
  530.     dst &= ~(1 << src);
  531.     put_byte(dsta,dst);
  532. }}}}
  533. void op_198(UWORD opcode)
  534. {
  535.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  536.     ULONG dstreg = (opcode & 7) >> 0;
  537. {{    BYTE src = regs.d[srcreg];
  538. {    CPTR dsta = regs.a[dstreg];
  539.     BYTE dst = get_byte(dsta);
  540. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  541.     src &= 7;
  542.     regs.z = !(dst & (1 << src));
  543.     dst &= ~(1 << src);
  544.     put_byte(dsta,dst);
  545. }}}}}
  546. void op_1a0(UWORD opcode)
  547. {
  548.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  549.     ULONG dstreg = (opcode & 7) >> 0;
  550. {{    BYTE src = regs.d[srcreg];
  551. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  552. {    CPTR dsta = regs.a[dstreg];
  553.     BYTE dst = get_byte(dsta);
  554.     src &= 7;
  555.     regs.z = !(dst & (1 << src));
  556.     dst &= ~(1 << src);
  557.     put_byte(dsta,dst);
  558. }}}}}
  559. void op_1a8(UWORD opcode)
  560. {
  561.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  562.     ULONG dstreg = (opcode & 7) >> 0;
  563. {{    BYTE src = regs.d[srcreg];
  564. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  565.     BYTE dst = get_byte(dsta);
  566.     src &= 7;
  567.     regs.z = !(dst & (1 << src));
  568.     dst &= ~(1 << src);
  569.     put_byte(dsta,dst);
  570. }}}}
  571. void op_1b0(UWORD opcode)
  572. {
  573.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  574.     ULONG dstreg = (opcode & 7) >> 0;
  575. {{    BYTE src = regs.d[srcreg];
  576. {    CPTR dsta = regs.a[dstreg];
  577.     UWORD dstdp = nextiword();
  578.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  579. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  580.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  581.     dsta += dstdpr;
  582. {    BYTE dst = get_byte(dsta);
  583.     src &= 7;
  584.     regs.z = !(dst & (1 << src));
  585.     dst &= ~(1 << src);
  586.     put_byte(dsta,dst);
  587. }}}}}}
  588. void op_1b8(UWORD opcode)
  589. {
  590.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  591. {{    BYTE src = regs.d[srcreg];
  592. {    CPTR dsta = (LONG)(WORD)nextiword();
  593.     BYTE dst = get_byte(dsta);
  594.     src &= 7;
  595.     regs.z = !(dst & (1 << src));
  596.     dst &= ~(1 << src);
  597.     put_byte(dsta,dst);
  598. }}}}
  599. void op_1b9(UWORD opcode)
  600. {
  601.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  602. {{    BYTE src = regs.d[srcreg];
  603. {    CPTR dsta = nextilong();
  604.     BYTE dst = get_byte(dsta);
  605.     src &= 7;
  606.     regs.z = !(dst & (1 << src));
  607.     dst &= ~(1 << src);
  608.     put_byte(dsta,dst);
  609. }}}}
  610. void op_1c0(UWORD opcode)
  611. {
  612.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  613.     ULONG dstreg = (opcode & 7) >> 0;
  614. {{    LONG src = regs.d[srcreg];
  615. {    LONG dst = regs.d[dstreg];
  616.     src &= 31;
  617.     regs.z = !(dst & (1 << src));
  618.     dst |= (1 << src);
  619.     regs.d[dstreg] = (dst);
  620. }}}}
  621. void op_1d0(UWORD opcode)
  622. {
  623.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  624.     ULONG dstreg = (opcode & 7) >> 0;
  625. {{    BYTE src = regs.d[srcreg];
  626. {    CPTR dsta = regs.a[dstreg];
  627.     BYTE dst = get_byte(dsta);
  628.     src &= 7;
  629.     regs.z = !(dst & (1 << src));
  630.     dst |= (1 << src);
  631.     put_byte(dsta,dst);
  632. }}}}
  633. void op_1d8(UWORD opcode)
  634. {
  635.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  636.     ULONG dstreg = (opcode & 7) >> 0;
  637. {{    BYTE src = regs.d[srcreg];
  638. {    CPTR dsta = regs.a[dstreg];
  639.     BYTE dst = get_byte(dsta);
  640. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  641.     src &= 7;
  642.     regs.z = !(dst & (1 << src));
  643.     dst |= (1 << src);
  644.     put_byte(dsta,dst);
  645. }}}}}
  646. void op_1e0(UWORD opcode)
  647. {
  648.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  649.     ULONG dstreg = (opcode & 7) >> 0;
  650. {{    BYTE src = regs.d[srcreg];
  651. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  652. {    CPTR dsta = regs.a[dstreg];
  653.     BYTE dst = get_byte(dsta);
  654.     src &= 7;
  655.     regs.z = !(dst & (1 << src));
  656.     dst |= (1 << src);
  657.     put_byte(dsta,dst);
  658. }}}}}
  659. void op_1e8(UWORD opcode)
  660. {
  661.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  662.     ULONG dstreg = (opcode & 7) >> 0;
  663. {{    BYTE src = regs.d[srcreg];
  664. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  665.     BYTE dst = get_byte(dsta);
  666.     src &= 7;
  667.     regs.z = !(dst & (1 << src));
  668.     dst |= (1 << src);
  669.     put_byte(dsta,dst);
  670. }}}}
  671. void op_1f0(UWORD opcode)
  672. {
  673.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  674.     ULONG dstreg = (opcode & 7) >> 0;
  675. {{    BYTE src = regs.d[srcreg];
  676. {    CPTR dsta = regs.a[dstreg];
  677.     UWORD dstdp = nextiword();
  678.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  679. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  680.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  681.     dsta += dstdpr;
  682. {    BYTE dst = get_byte(dsta);
  683.     src &= 7;
  684.     regs.z = !(dst & (1 << src));
  685.     dst |= (1 << src);
  686.     put_byte(dsta,dst);
  687. }}}}}}
  688. void op_1f8(UWORD opcode)
  689. {
  690.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  691. {{    BYTE src = regs.d[srcreg];
  692. {    CPTR dsta = (LONG)(WORD)nextiword();
  693.     BYTE dst = get_byte(dsta);
  694.     src &= 7;
  695.     regs.z = !(dst & (1 << src));
  696.     dst |= (1 << src);
  697.     put_byte(dsta,dst);
  698. }}}}
  699. void op_1f9(UWORD opcode)
  700. {
  701.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  702. {{    BYTE src = regs.d[srcreg];
  703. {    CPTR dsta = nextilong();
  704.     BYTE dst = get_byte(dsta);
  705.     src &= 7;
  706.     regs.z = !(dst & (1 << src));
  707.     dst |= (1 << src);
  708.     put_byte(dsta,dst);
  709. }}}}
  710. void op_200(UWORD opcode)
  711. {
  712.     ULONG dstreg = (opcode & 7) >> 0;
  713. {{    BYTE src = nextiword();
  714. {    BYTE dst = regs.d[dstreg];
  715.     src &= dst;
  716.     regs.v = regs.c = 0;
  717.     regs.z = ((BYTE)(src)) == 0;
  718.     regs.n = ((BYTE)(src)) < 0;
  719.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  720. }}}}
  721. void op_210(UWORD opcode)
  722. {
  723.     ULONG dstreg = (opcode & 7) >> 0;
  724. {{    BYTE src = nextiword();
  725. {    CPTR dsta = regs.a[dstreg];
  726.     BYTE dst = get_byte(dsta);
  727.     src &= dst;
  728.     regs.v = regs.c = 0;
  729.     regs.z = ((BYTE)(src)) == 0;
  730.     regs.n = ((BYTE)(src)) < 0;
  731.     put_byte(dsta,src);
  732. }}}}
  733. void op_218(UWORD opcode)
  734. {
  735.     ULONG dstreg = (opcode & 7) >> 0;
  736. {{    BYTE src = nextiword();
  737. {    CPTR dsta = regs.a[dstreg];
  738.     BYTE dst = get_byte(dsta);
  739. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  740.     src &= dst;
  741.     regs.v = regs.c = 0;
  742.     regs.z = ((BYTE)(src)) == 0;
  743.     regs.n = ((BYTE)(src)) < 0;
  744.     put_byte(dsta,src);
  745. }}}}}
  746. void op_220(UWORD opcode)
  747. {
  748.     ULONG dstreg = (opcode & 7) >> 0;
  749. {{    BYTE src = nextiword();
  750. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  751. {    CPTR dsta = regs.a[dstreg];
  752.     BYTE dst = get_byte(dsta);
  753.     src &= dst;
  754.     regs.v = regs.c = 0;
  755.     regs.z = ((BYTE)(src)) == 0;
  756.     regs.n = ((BYTE)(src)) < 0;
  757.     put_byte(dsta,src);
  758. }}}}}
  759. void op_228(UWORD opcode)
  760. {
  761.     ULONG dstreg = (opcode & 7) >> 0;
  762. {{    BYTE src = nextiword();
  763. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  764.     BYTE dst = get_byte(dsta);
  765.     src &= dst;
  766.     regs.v = regs.c = 0;
  767.     regs.z = ((BYTE)(src)) == 0;
  768.     regs.n = ((BYTE)(src)) < 0;
  769.     put_byte(dsta,src);
  770. }}}}
  771. void op_230(UWORD opcode)
  772. {
  773.     ULONG dstreg = (opcode & 7) >> 0;
  774. {{    BYTE src = nextiword();
  775. {    CPTR dsta = regs.a[dstreg];
  776.     UWORD dstdp = nextiword();
  777.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  778. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  779.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  780.     dsta += dstdpr;
  781. {    BYTE dst = get_byte(dsta);
  782.     src &= dst;
  783.     regs.v = regs.c = 0;
  784.     regs.z = ((BYTE)(src)) == 0;
  785.     regs.n = ((BYTE)(src)) < 0;
  786.     put_byte(dsta,src);
  787. }}}}}}
  788. void op_238(UWORD opcode)
  789. {
  790. {{    BYTE src = nextiword();
  791. {    CPTR dsta = (LONG)(WORD)nextiword();
  792.     BYTE dst = get_byte(dsta);
  793.     src &= dst;
  794.     regs.v = regs.c = 0;
  795.     regs.z = ((BYTE)(src)) == 0;
  796.     regs.n = ((BYTE)(src)) < 0;
  797.     put_byte(dsta,src);
  798. }}}}
  799. void op_239(UWORD opcode)
  800. {
  801. {{    BYTE src = nextiword();
  802. {    CPTR dsta = nextilong();
  803.     BYTE dst = get_byte(dsta);
  804.     src &= dst;
  805.     regs.v = regs.c = 0;
  806.     regs.z = ((BYTE)(src)) == 0;
  807.     regs.n = ((BYTE)(src)) < 0;
  808.     put_byte(dsta,src);
  809. }}}}
  810. void op_23c(UWORD opcode)
  811. {
  812. {{    MakeSR();
  813. {    WORD src = nextiword();
  814.     src |= 0xFF00;
  815.     regs.sr &= src;
  816.     MakeFromSR();
  817. }}}}
  818. void op_240(UWORD opcode)
  819. {
  820.     ULONG dstreg = (opcode & 7) >> 0;
  821. {{    WORD src = nextiword();
  822. {    WORD dst = regs.d[dstreg];
  823.     src &= dst;
  824.     regs.v = regs.c = 0;
  825.     regs.z = ((WORD)(src)) == 0;
  826.     regs.n = ((WORD)(src)) < 0;
  827.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  828. }}}}
  829. void op_250(UWORD opcode)
  830. {
  831.     ULONG dstreg = (opcode & 7) >> 0;
  832. {{    WORD src = nextiword();
  833. {    CPTR dsta = regs.a[dstreg];
  834.     WORD dst = get_word(dsta);
  835.     src &= dst;
  836.     regs.v = regs.c = 0;
  837.     regs.z = ((WORD)(src)) == 0;
  838.     regs.n = ((WORD)(src)) < 0;
  839.     put_word(dsta,src);
  840. }}}}
  841. void op_258(UWORD opcode)
  842. {
  843.     ULONG dstreg = (opcode & 7) >> 0;
  844. {{    WORD src = nextiword();
  845. {    CPTR dsta = regs.a[dstreg];
  846.     WORD dst = get_word(dsta);
  847. {    regs.a[dstreg] += 2;
  848.     src &= dst;
  849.     regs.v = regs.c = 0;
  850.     regs.z = ((WORD)(src)) == 0;
  851.     regs.n = ((WORD)(src)) < 0;
  852.     put_word(dsta,src);
  853. }}}}}
  854. void op_260(UWORD opcode)
  855. {
  856.     ULONG dstreg = (opcode & 7) >> 0;
  857. {{    WORD src = nextiword();
  858. {    regs.a[dstreg] -= 2;
  859. {    CPTR dsta = regs.a[dstreg];
  860.     WORD dst = get_word(dsta);
  861.     src &= dst;
  862.     regs.v = regs.c = 0;
  863.     regs.z = ((WORD)(src)) == 0;
  864.     regs.n = ((WORD)(src)) < 0;
  865.     put_word(dsta,src);
  866. }}}}}
  867. void op_268(UWORD opcode)
  868. {
  869.     ULONG dstreg = (opcode & 7) >> 0;
  870. {{    WORD src = nextiword();
  871. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  872.     WORD dst = get_word(dsta);
  873.     src &= dst;
  874.     regs.v = regs.c = 0;
  875.     regs.z = ((WORD)(src)) == 0;
  876.     regs.n = ((WORD)(src)) < 0;
  877.     put_word(dsta,src);
  878. }}}}
  879. void op_270(UWORD opcode)
  880. {
  881.     ULONG dstreg = (opcode & 7) >> 0;
  882. {{    WORD src = nextiword();
  883. {    CPTR dsta = regs.a[dstreg];
  884.     UWORD dstdp = nextiword();
  885.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  886. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  887.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  888.     dsta += dstdpr;
  889. {    WORD dst = get_word(dsta);
  890.     src &= dst;
  891.     regs.v = regs.c = 0;
  892.     regs.z = ((WORD)(src)) == 0;
  893.     regs.n = ((WORD)(src)) < 0;
  894.     put_word(dsta,src);
  895. }}}}}}
  896. void op_278(UWORD opcode)
  897. {
  898. {{    WORD src = nextiword();
  899. {    CPTR dsta = (LONG)(WORD)nextiword();
  900.     WORD dst = get_word(dsta);
  901.     src &= dst;
  902.     regs.v = regs.c = 0;
  903.     regs.z = ((WORD)(src)) == 0;
  904.     regs.n = ((WORD)(src)) < 0;
  905.     put_word(dsta,src);
  906. }}}}
  907. void op_279(UWORD opcode)
  908. {
  909. {{    WORD src = nextiword();
  910. {    CPTR dsta = nextilong();
  911.     WORD dst = get_word(dsta);
  912.     src &= dst;
  913.     regs.v = regs.c = 0;
  914.     regs.z = ((WORD)(src)) == 0;
  915.     regs.n = ((WORD)(src)) < 0;
  916.     put_word(dsta,src);
  917. }}}}
  918. void op_27c(UWORD opcode)
  919. {
  920. {    if (!regs.s) { regs.pc_p--; Exception(8); } else
  921. {    MakeSR();
  922. {    WORD src = nextiword();
  923.     regs.sr &= src;
  924.     MakeFromSR();
  925. }}}}
  926. void op_280(UWORD opcode)
  927. {
  928.     ULONG dstreg = (opcode & 7) >> 0;
  929. {{    LONG src = nextilong();
  930. {    LONG dst = regs.d[dstreg];
  931.     src &= dst;
  932.     regs.v = regs.c = 0;
  933.     regs.z = ((LONG)(src)) == 0;
  934.     regs.n = ((LONG)(src)) < 0;
  935.     regs.d[dstreg] = (src);
  936. }}}}
  937. void op_290(UWORD opcode)
  938. {
  939.     ULONG dstreg = (opcode & 7) >> 0;
  940. {{    LONG src = nextilong();
  941. {    CPTR dsta = regs.a[dstreg];
  942.     LONG dst = get_long(dsta);
  943.     src &= dst;
  944.     regs.v = regs.c = 0;
  945.     regs.z = ((LONG)(src)) == 0;
  946.     regs.n = ((LONG)(src)) < 0;
  947.     put_long(dsta,src);
  948. }}}}
  949. void op_298(UWORD opcode)
  950. {
  951.     ULONG dstreg = (opcode & 7) >> 0;
  952. {{    LONG src = nextilong();
  953. {    CPTR dsta = regs.a[dstreg];
  954.     LONG dst = get_long(dsta);
  955. {    regs.a[dstreg] += 4;
  956.     src &= dst;
  957.     regs.v = regs.c = 0;
  958.     regs.z = ((LONG)(src)) == 0;
  959.     regs.n = ((LONG)(src)) < 0;
  960.     put_long(dsta,src);
  961. }}}}}
  962. void op_2a0(UWORD opcode)
  963. {
  964.     ULONG dstreg = (opcode & 7) >> 0;
  965. {{    LONG src = nextilong();
  966. {    regs.a[dstreg] -= 4;
  967. {    CPTR dsta = regs.a[dstreg];
  968.     LONG dst = get_long(dsta);
  969.     src &= dst;
  970.     regs.v = regs.c = 0;
  971.     regs.z = ((LONG)(src)) == 0;
  972.     regs.n = ((LONG)(src)) < 0;
  973.     put_long(dsta,src);
  974. }}}}}
  975. void op_2a8(UWORD opcode)
  976. {
  977.     ULONG dstreg = (opcode & 7) >> 0;
  978. {{    LONG src = nextilong();
  979. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  980.     LONG dst = get_long(dsta);
  981.     src &= dst;
  982.     regs.v = regs.c = 0;
  983.     regs.z = ((LONG)(src)) == 0;
  984.     regs.n = ((LONG)(src)) < 0;
  985.     put_long(dsta,src);
  986. }}}}
  987. void op_2b0(UWORD opcode)
  988. {
  989.     ULONG dstreg = (opcode & 7) >> 0;
  990. {{    LONG src = nextilong();
  991. {    CPTR dsta = regs.a[dstreg];
  992.     UWORD dstdp = nextiword();
  993.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  994. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  995.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  996.     dsta += dstdpr;
  997. {    LONG dst = get_long(dsta);
  998.     src &= dst;
  999.     regs.v = regs.c = 0;
  1000.     regs.z = ((LONG)(src)) == 0;
  1001.     regs.n = ((LONG)(src)) < 0;
  1002.     put_long(dsta,src);
  1003. }}}}}}
  1004. void op_2b8(UWORD opcode)
  1005. {
  1006. {{    LONG src = nextilong();
  1007. {    CPTR dsta = (LONG)(WORD)nextiword();
  1008.     LONG dst = get_long(dsta);
  1009.     src &= dst;
  1010.     regs.v = regs.c = 0;
  1011.     regs.z = ((LONG)(src)) == 0;
  1012.     regs.n = ((LONG)(src)) < 0;
  1013.     put_long(dsta,src);
  1014. }}}}
  1015. void op_2b9(UWORD opcode)
  1016. {
  1017. {{    LONG src = nextilong();
  1018. {    CPTR dsta = nextilong();
  1019.     LONG dst = get_long(dsta);
  1020.     src &= dst;
  1021.     regs.v = regs.c = 0;
  1022.     regs.z = ((LONG)(src)) == 0;
  1023.     regs.n = ((LONG)(src)) < 0;
  1024.     put_long(dsta,src);
  1025. }}}}
  1026. void op_400(UWORD opcode)
  1027. {
  1028.     ULONG dstreg = (opcode & 7) >> 0;
  1029. {{    BYTE src = nextiword();
  1030. {    BYTE dst = regs.d[dstreg];
  1031. {    ULONG newv = dst - src;
  1032. {    bool flgs = ((BYTE)(src)) < 0;
  1033.     bool flgo = ((BYTE)(dst)) < 0;
  1034.     bool flgn = ((BYTE)(newv)) < 0;
  1035.     regs.z = ((BYTE)(newv)) == 0;
  1036.     regs.v = (flgs != flgo) && (flgn != flgo);
  1037.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1038.     regs.n = flgn != 0;
  1039.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  1040. }}}}}}
  1041. void op_410(UWORD opcode)
  1042. {
  1043.     ULONG dstreg = (opcode & 7) >> 0;
  1044. {{    BYTE src = nextiword();
  1045. {    CPTR dsta = regs.a[dstreg];
  1046.     BYTE dst = get_byte(dsta);
  1047. {    ULONG newv = dst - src;
  1048. {    bool flgs = ((BYTE)(src)) < 0;
  1049.     bool flgo = ((BYTE)(dst)) < 0;
  1050.     bool flgn = ((BYTE)(newv)) < 0;
  1051.     regs.z = ((BYTE)(newv)) == 0;
  1052.     regs.v = (flgs != flgo) && (flgn != flgo);
  1053.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1054.     regs.n = flgn != 0;
  1055.     put_byte(dsta,newv);
  1056. }}}}}}
  1057. void op_418(UWORD opcode)
  1058. {
  1059.     ULONG dstreg = (opcode & 7) >> 0;
  1060. {{    BYTE src = nextiword();
  1061. {    CPTR dsta = regs.a[dstreg];
  1062.     BYTE dst = get_byte(dsta);
  1063. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  1064. {    ULONG newv = dst - src;
  1065. {    bool flgs = ((BYTE)(src)) < 0;
  1066.     bool flgo = ((BYTE)(dst)) < 0;
  1067.     bool flgn = ((BYTE)(newv)) < 0;
  1068.     regs.z = ((BYTE)(newv)) == 0;
  1069.     regs.v = (flgs != flgo) && (flgn != flgo);
  1070.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1071.     regs.n = flgn != 0;
  1072.     put_byte(dsta,newv);
  1073. }}}}}}}
  1074. void op_420(UWORD opcode)
  1075. {
  1076.     ULONG dstreg = (opcode & 7) >> 0;
  1077. {{    BYTE src = nextiword();
  1078. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  1079. {    CPTR dsta = regs.a[dstreg];
  1080.     BYTE dst = get_byte(dsta);
  1081. {    ULONG newv = dst - src;
  1082. {    bool flgs = ((BYTE)(src)) < 0;
  1083.     bool flgo = ((BYTE)(dst)) < 0;
  1084.     bool flgn = ((BYTE)(newv)) < 0;
  1085.     regs.z = ((BYTE)(newv)) == 0;
  1086.     regs.v = (flgs != flgo) && (flgn != flgo);
  1087.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1088.     regs.n = flgn != 0;
  1089.     put_byte(dsta,newv);
  1090. }}}}}}}
  1091. void op_428(UWORD opcode)
  1092. {
  1093.     ULONG dstreg = (opcode & 7) >> 0;
  1094. {{    BYTE src = nextiword();
  1095. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1096.     BYTE dst = get_byte(dsta);
  1097. {    ULONG newv = dst - src;
  1098. {    bool flgs = ((BYTE)(src)) < 0;
  1099.     bool flgo = ((BYTE)(dst)) < 0;
  1100.     bool flgn = ((BYTE)(newv)) < 0;
  1101.     regs.z = ((BYTE)(newv)) == 0;
  1102.     regs.v = (flgs != flgo) && (flgn != flgo);
  1103.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1104.     regs.n = flgn != 0;
  1105.     put_byte(dsta,newv);
  1106. }}}}}}
  1107. void op_430(UWORD opcode)
  1108. {
  1109.     ULONG dstreg = (opcode & 7) >> 0;
  1110. {{    BYTE src = nextiword();
  1111. {    CPTR dsta = regs.a[dstreg];
  1112.     UWORD dstdp = nextiword();
  1113.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1114. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1115.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1116.     dsta += dstdpr;
  1117. {    BYTE dst = get_byte(dsta);
  1118. {    ULONG newv = dst - src;
  1119. {    bool flgs = ((BYTE)(src)) < 0;
  1120.     bool flgo = ((BYTE)(dst)) < 0;
  1121.     bool flgn = ((BYTE)(newv)) < 0;
  1122.     regs.z = ((BYTE)(newv)) == 0;
  1123.     regs.v = (flgs != flgo) && (flgn != flgo);
  1124.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1125.     regs.n = flgn != 0;
  1126.     put_byte(dsta,newv);
  1127. }}}}}}}}
  1128. void op_438(UWORD opcode)
  1129. {
  1130. {{    BYTE src = nextiword();
  1131. {    CPTR dsta = (LONG)(WORD)nextiword();
  1132.     BYTE dst = get_byte(dsta);
  1133. {    ULONG newv = dst - src;
  1134. {    bool flgs = ((BYTE)(src)) < 0;
  1135.     bool flgo = ((BYTE)(dst)) < 0;
  1136.     bool flgn = ((BYTE)(newv)) < 0;
  1137.     regs.z = ((BYTE)(newv)) == 0;
  1138.     regs.v = (flgs != flgo) && (flgn != flgo);
  1139.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1140.     regs.n = flgn != 0;
  1141.     put_byte(dsta,newv);
  1142. }}}}}}
  1143. void op_439(UWORD opcode)
  1144. {
  1145. {{    BYTE src = nextiword();
  1146. {    CPTR dsta = nextilong();
  1147.     BYTE dst = get_byte(dsta);
  1148. {    ULONG newv = dst - src;
  1149. {    bool flgs = ((BYTE)(src)) < 0;
  1150.     bool flgo = ((BYTE)(dst)) < 0;
  1151.     bool flgn = ((BYTE)(newv)) < 0;
  1152.     regs.z = ((BYTE)(newv)) == 0;
  1153.     regs.v = (flgs != flgo) && (flgn != flgo);
  1154.     regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
  1155.     regs.n = flgn != 0;
  1156.     put_byte(dsta,newv);
  1157. }}}}}}
  1158. void op_440(UWORD opcode)
  1159. {
  1160.     ULONG dstreg = (opcode & 7) >> 0;
  1161. {{    WORD src = nextiword();
  1162. {    WORD dst = regs.d[dstreg];
  1163. {    ULONG newv = dst - src;
  1164. {    bool flgs = ((WORD)(src)) < 0;
  1165.     bool flgo = ((WORD)(dst)) < 0;
  1166.     bool flgn = ((WORD)(newv)) < 0;
  1167.     regs.z = ((WORD)(newv)) == 0;
  1168.     regs.v = (flgs != flgo) && (flgn != flgo);
  1169.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1170.     regs.n = flgn != 0;
  1171.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  1172. }}}}}}
  1173. void op_450(UWORD opcode)
  1174. {
  1175.     ULONG dstreg = (opcode & 7) >> 0;
  1176. {{    WORD src = nextiword();
  1177. {    CPTR dsta = regs.a[dstreg];
  1178.     WORD dst = get_word(dsta);
  1179. {    ULONG newv = dst - src;
  1180. {    bool flgs = ((WORD)(src)) < 0;
  1181.     bool flgo = ((WORD)(dst)) < 0;
  1182.     bool flgn = ((WORD)(newv)) < 0;
  1183.     regs.z = ((WORD)(newv)) == 0;
  1184.     regs.v = (flgs != flgo) && (flgn != flgo);
  1185.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1186.     regs.n = flgn != 0;
  1187.     put_word(dsta,newv);
  1188. }}}}}}
  1189. void op_458(UWORD opcode)
  1190. {
  1191.     ULONG dstreg = (opcode & 7) >> 0;
  1192. {{    WORD src = nextiword();
  1193. {    CPTR dsta = regs.a[dstreg];
  1194.     WORD dst = get_word(dsta);
  1195. {    regs.a[dstreg] += 2;
  1196. {    ULONG newv = dst - src;
  1197. {    bool flgs = ((WORD)(src)) < 0;
  1198.     bool flgo = ((WORD)(dst)) < 0;
  1199.     bool flgn = ((WORD)(newv)) < 0;
  1200.     regs.z = ((WORD)(newv)) == 0;
  1201.     regs.v = (flgs != flgo) && (flgn != flgo);
  1202.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1203.     regs.n = flgn != 0;
  1204.     put_word(dsta,newv);
  1205. }}}}}}}
  1206. void op_460(UWORD opcode)
  1207. {
  1208.     ULONG dstreg = (opcode & 7) >> 0;
  1209. {{    WORD src = nextiword();
  1210. {    regs.a[dstreg] -= 2;
  1211. {    CPTR dsta = regs.a[dstreg];
  1212.     WORD dst = get_word(dsta);
  1213. {    ULONG newv = dst - src;
  1214. {    bool flgs = ((WORD)(src)) < 0;
  1215.     bool flgo = ((WORD)(dst)) < 0;
  1216.     bool flgn = ((WORD)(newv)) < 0;
  1217.     regs.z = ((WORD)(newv)) == 0;
  1218.     regs.v = (flgs != flgo) && (flgn != flgo);
  1219.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1220.     regs.n = flgn != 0;
  1221.     put_word(dsta,newv);
  1222. }}}}}}}
  1223. void op_468(UWORD opcode)
  1224. {
  1225.     ULONG dstreg = (opcode & 7) >> 0;
  1226. {{    WORD src = nextiword();
  1227. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1228.     WORD dst = get_word(dsta);
  1229. {    ULONG newv = dst - src;
  1230. {    bool flgs = ((WORD)(src)) < 0;
  1231.     bool flgo = ((WORD)(dst)) < 0;
  1232.     bool flgn = ((WORD)(newv)) < 0;
  1233.     regs.z = ((WORD)(newv)) == 0;
  1234.     regs.v = (flgs != flgo) && (flgn != flgo);
  1235.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1236.     regs.n = flgn != 0;
  1237.     put_word(dsta,newv);
  1238. }}}}}}
  1239. void op_470(UWORD opcode)
  1240. {
  1241.     ULONG dstreg = (opcode & 7) >> 0;
  1242. {{    WORD src = nextiword();
  1243. {    CPTR dsta = regs.a[dstreg];
  1244.     UWORD dstdp = nextiword();
  1245.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1246. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1247.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1248.     dsta += dstdpr;
  1249. {    WORD dst = get_word(dsta);
  1250. {    ULONG newv = dst - src;
  1251. {    bool flgs = ((WORD)(src)) < 0;
  1252.     bool flgo = ((WORD)(dst)) < 0;
  1253.     bool flgn = ((WORD)(newv)) < 0;
  1254.     regs.z = ((WORD)(newv)) == 0;
  1255.     regs.v = (flgs != flgo) && (flgn != flgo);
  1256.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1257.     regs.n = flgn != 0;
  1258.     put_word(dsta,newv);
  1259. }}}}}}}}
  1260. void op_478(UWORD opcode)
  1261. {
  1262. {{    WORD src = nextiword();
  1263. {    CPTR dsta = (LONG)(WORD)nextiword();
  1264.     WORD dst = get_word(dsta);
  1265. {    ULONG newv = dst - src;
  1266. {    bool flgs = ((WORD)(src)) < 0;
  1267.     bool flgo = ((WORD)(dst)) < 0;
  1268.     bool flgn = ((WORD)(newv)) < 0;
  1269.     regs.z = ((WORD)(newv)) == 0;
  1270.     regs.v = (flgs != flgo) && (flgn != flgo);
  1271.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1272.     regs.n = flgn != 0;
  1273.     put_word(dsta,newv);
  1274. }}}}}}
  1275. void op_479(UWORD opcode)
  1276. {
  1277. {{    WORD src = nextiword();
  1278. {    CPTR dsta = nextilong();
  1279.     WORD dst = get_word(dsta);
  1280. {    ULONG newv = dst - src;
  1281. {    bool flgs = ((WORD)(src)) < 0;
  1282.     bool flgo = ((WORD)(dst)) < 0;
  1283.     bool flgn = ((WORD)(newv)) < 0;
  1284.     regs.z = ((WORD)(newv)) == 0;
  1285.     regs.v = (flgs != flgo) && (flgn != flgo);
  1286.     regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
  1287.     regs.n = flgn != 0;
  1288.     put_word(dsta,newv);
  1289. }}}}}}
  1290. void op_480(UWORD opcode)
  1291. {
  1292.     ULONG dstreg = (opcode & 7) >> 0;
  1293. {{    LONG src = nextilong();
  1294. {    LONG dst = regs.d[dstreg];
  1295. {    ULONG newv = dst - src;
  1296. {    bool flgs = ((LONG)(src)) < 0;
  1297.     bool flgo = ((LONG)(dst)) < 0;
  1298.     bool flgn = ((LONG)(newv)) < 0;
  1299.     regs.z = ((LONG)(newv)) == 0;
  1300.     regs.v = (flgs != flgo) && (flgn != flgo);
  1301.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1302.     regs.n = flgn != 0;
  1303.     regs.d[dstreg] = (newv);
  1304. }}}}}}
  1305. void op_490(UWORD opcode)
  1306. {
  1307.     ULONG dstreg = (opcode & 7) >> 0;
  1308. {{    LONG src = nextilong();
  1309. {    CPTR dsta = regs.a[dstreg];
  1310.     LONG dst = get_long(dsta);
  1311. {    ULONG newv = dst - src;
  1312. {    bool flgs = ((LONG)(src)) < 0;
  1313.     bool flgo = ((LONG)(dst)) < 0;
  1314.     bool flgn = ((LONG)(newv)) < 0;
  1315.     regs.z = ((LONG)(newv)) == 0;
  1316.     regs.v = (flgs != flgo) && (flgn != flgo);
  1317.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1318.     regs.n = flgn != 0;
  1319.     put_long(dsta,newv);
  1320. }}}}}}
  1321. void op_498(UWORD opcode)
  1322. {
  1323.     ULONG dstreg = (opcode & 7) >> 0;
  1324. {{    LONG src = nextilong();
  1325. {    CPTR dsta = regs.a[dstreg];
  1326.     LONG dst = get_long(dsta);
  1327. {    regs.a[dstreg] += 4;
  1328. {    ULONG newv = dst - src;
  1329. {    bool flgs = ((LONG)(src)) < 0;
  1330.     bool flgo = ((LONG)(dst)) < 0;
  1331.     bool flgn = ((LONG)(newv)) < 0;
  1332.     regs.z = ((LONG)(newv)) == 0;
  1333.     regs.v = (flgs != flgo) && (flgn != flgo);
  1334.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1335.     regs.n = flgn != 0;
  1336.     put_long(dsta,newv);
  1337. }}}}}}}
  1338. void op_4a0(UWORD opcode)
  1339. {
  1340.     ULONG dstreg = (opcode & 7) >> 0;
  1341. {{    LONG src = nextilong();
  1342. {    regs.a[dstreg] -= 4;
  1343. {    CPTR dsta = regs.a[dstreg];
  1344.     LONG dst = get_long(dsta);
  1345. {    ULONG newv = dst - src;
  1346. {    bool flgs = ((LONG)(src)) < 0;
  1347.     bool flgo = ((LONG)(dst)) < 0;
  1348.     bool flgn = ((LONG)(newv)) < 0;
  1349.     regs.z = ((LONG)(newv)) == 0;
  1350.     regs.v = (flgs != flgo) && (flgn != flgo);
  1351.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1352.     regs.n = flgn != 0;
  1353.     put_long(dsta,newv);
  1354. }}}}}}}
  1355. void op_4a8(UWORD opcode)
  1356. {
  1357.     ULONG dstreg = (opcode & 7) >> 0;
  1358. {{    LONG src = nextilong();
  1359. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1360.     LONG dst = get_long(dsta);
  1361. {    ULONG newv = dst - src;
  1362. {    bool flgs = ((LONG)(src)) < 0;
  1363.     bool flgo = ((LONG)(dst)) < 0;
  1364.     bool flgn = ((LONG)(newv)) < 0;
  1365.     regs.z = ((LONG)(newv)) == 0;
  1366.     regs.v = (flgs != flgo) && (flgn != flgo);
  1367.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1368.     regs.n = flgn != 0;
  1369.     put_long(dsta,newv);
  1370. }}}}}}
  1371. void op_4b0(UWORD opcode)
  1372. {
  1373.     ULONG dstreg = (opcode & 7) >> 0;
  1374. {{    LONG src = nextilong();
  1375. {    CPTR dsta = regs.a[dstreg];
  1376.     UWORD dstdp = nextiword();
  1377.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1378. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1379.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1380.     dsta += dstdpr;
  1381. {    LONG dst = get_long(dsta);
  1382. {    ULONG newv = dst - src;
  1383. {    bool flgs = ((LONG)(src)) < 0;
  1384.     bool flgo = ((LONG)(dst)) < 0;
  1385.     bool flgn = ((LONG)(newv)) < 0;
  1386.     regs.z = ((LONG)(newv)) == 0;
  1387.     regs.v = (flgs != flgo) && (flgn != flgo);
  1388.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1389.     regs.n = flgn != 0;
  1390.     put_long(dsta,newv);
  1391. }}}}}}}}
  1392. void op_4b8(UWORD opcode)
  1393. {
  1394. {{    LONG src = nextilong();
  1395. {    CPTR dsta = (LONG)(WORD)nextiword();
  1396.     LONG dst = get_long(dsta);
  1397. {    ULONG newv = dst - src;
  1398. {    bool flgs = ((LONG)(src)) < 0;
  1399.     bool flgo = ((LONG)(dst)) < 0;
  1400.     bool flgn = ((LONG)(newv)) < 0;
  1401.     regs.z = ((LONG)(newv)) == 0;
  1402.     regs.v = (flgs != flgo) && (flgn != flgo);
  1403.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1404.     regs.n = flgn != 0;
  1405.     put_long(dsta,newv);
  1406. }}}}}}
  1407. void op_4b9(UWORD opcode)
  1408. {
  1409. {{    LONG src = nextilong();
  1410. {    CPTR dsta = nextilong();
  1411.     LONG dst = get_long(dsta);
  1412. {    ULONG newv = dst - src;
  1413. {    bool flgs = ((LONG)(src)) < 0;
  1414.     bool flgo = ((LONG)(dst)) < 0;
  1415.     bool flgn = ((LONG)(newv)) < 0;
  1416.     regs.z = ((LONG)(newv)) == 0;
  1417.     regs.v = (flgs != flgo) && (flgn != flgo);
  1418.     regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
  1419.     regs.n = flgn != 0;
  1420.     put_long(dsta,newv);
  1421. }}}}}}
  1422. void op_600(UWORD opcode)
  1423. {
  1424.     ULONG dstreg = (opcode & 7) >> 0;
  1425. {{    BYTE src = nextiword();
  1426. {    BYTE dst = regs.d[dstreg];
  1427. {    ULONG newv = dst + src;
  1428. {    bool flgs = ((BYTE)(src)) < 0;
  1429.     bool flgo = ((BYTE)(dst)) < 0;
  1430.     bool flgn = ((BYTE)(newv)) < 0;
  1431.     regs.z = ((BYTE)(newv)) == 0;
  1432.     regs.v = (flgs == flgo) && (flgn != flgo);
  1433.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1434.     regs.n = flgn != 0;
  1435.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  1436. }}}}}}
  1437. void op_610(UWORD opcode)
  1438. {
  1439.     ULONG dstreg = (opcode & 7) >> 0;
  1440. {{    BYTE src = nextiword();
  1441. {    CPTR dsta = regs.a[dstreg];
  1442.     BYTE dst = get_byte(dsta);
  1443. {    ULONG newv = dst + src;
  1444. {    bool flgs = ((BYTE)(src)) < 0;
  1445.     bool flgo = ((BYTE)(dst)) < 0;
  1446.     bool flgn = ((BYTE)(newv)) < 0;
  1447.     regs.z = ((BYTE)(newv)) == 0;
  1448.     regs.v = (flgs == flgo) && (flgn != flgo);
  1449.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1450.     regs.n = flgn != 0;
  1451.     put_byte(dsta,newv);
  1452. }}}}}}
  1453. void op_618(UWORD opcode)
  1454. {
  1455.     ULONG dstreg = (opcode & 7) >> 0;
  1456. {{    BYTE src = nextiword();
  1457. {    CPTR dsta = regs.a[dstreg];
  1458.     BYTE dst = get_byte(dsta);
  1459. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  1460. {    ULONG newv = dst + src;
  1461. {    bool flgs = ((BYTE)(src)) < 0;
  1462.     bool flgo = ((BYTE)(dst)) < 0;
  1463.     bool flgn = ((BYTE)(newv)) < 0;
  1464.     regs.z = ((BYTE)(newv)) == 0;
  1465.     regs.v = (flgs == flgo) && (flgn != flgo);
  1466.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1467.     regs.n = flgn != 0;
  1468.     put_byte(dsta,newv);
  1469. }}}}}}}
  1470. void op_620(UWORD opcode)
  1471. {
  1472.     ULONG dstreg = (opcode & 7) >> 0;
  1473. {{    BYTE src = nextiword();
  1474. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  1475. {    CPTR dsta = regs.a[dstreg];
  1476.     BYTE dst = get_byte(dsta);
  1477. {    ULONG newv = dst + src;
  1478. {    bool flgs = ((BYTE)(src)) < 0;
  1479.     bool flgo = ((BYTE)(dst)) < 0;
  1480.     bool flgn = ((BYTE)(newv)) < 0;
  1481.     regs.z = ((BYTE)(newv)) == 0;
  1482.     regs.v = (flgs == flgo) && (flgn != flgo);
  1483.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1484.     regs.n = flgn != 0;
  1485.     put_byte(dsta,newv);
  1486. }}}}}}}
  1487. void op_628(UWORD opcode)
  1488. {
  1489.     ULONG dstreg = (opcode & 7) >> 0;
  1490. {{    BYTE src = nextiword();
  1491. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1492.     BYTE dst = get_byte(dsta);
  1493. {    ULONG newv = dst + src;
  1494. {    bool flgs = ((BYTE)(src)) < 0;
  1495.     bool flgo = ((BYTE)(dst)) < 0;
  1496.     bool flgn = ((BYTE)(newv)) < 0;
  1497.     regs.z = ((BYTE)(newv)) == 0;
  1498.     regs.v = (flgs == flgo) && (flgn != flgo);
  1499.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1500.     regs.n = flgn != 0;
  1501.     put_byte(dsta,newv);
  1502. }}}}}}
  1503. void op_630(UWORD opcode)
  1504. {
  1505.     ULONG dstreg = (opcode & 7) >> 0;
  1506. {{    BYTE src = nextiword();
  1507. {    CPTR dsta = regs.a[dstreg];
  1508.     UWORD dstdp = nextiword();
  1509.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1510. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1511.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1512.     dsta += dstdpr;
  1513. {    BYTE dst = get_byte(dsta);
  1514. {    ULONG newv = dst + src;
  1515. {    bool flgs = ((BYTE)(src)) < 0;
  1516.     bool flgo = ((BYTE)(dst)) < 0;
  1517.     bool flgn = ((BYTE)(newv)) < 0;
  1518.     regs.z = ((BYTE)(newv)) == 0;
  1519.     regs.v = (flgs == flgo) && (flgn != flgo);
  1520.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1521.     regs.n = flgn != 0;
  1522.     put_byte(dsta,newv);
  1523. }}}}}}}}
  1524. void op_638(UWORD opcode)
  1525. {
  1526. {{    BYTE src = nextiword();
  1527. {    CPTR dsta = (LONG)(WORD)nextiword();
  1528.     BYTE dst = get_byte(dsta);
  1529. {    ULONG newv = dst + src;
  1530. {    bool flgs = ((BYTE)(src)) < 0;
  1531.     bool flgo = ((BYTE)(dst)) < 0;
  1532.     bool flgn = ((BYTE)(newv)) < 0;
  1533.     regs.z = ((BYTE)(newv)) == 0;
  1534.     regs.v = (flgs == flgo) && (flgn != flgo);
  1535.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1536.     regs.n = flgn != 0;
  1537.     put_byte(dsta,newv);
  1538. }}}}}}
  1539. void op_639(UWORD opcode)
  1540. {
  1541. {{    BYTE src = nextiword();
  1542. {    CPTR dsta = nextilong();
  1543.     BYTE dst = get_byte(dsta);
  1544. {    ULONG newv = dst + src;
  1545. {    bool flgs = ((BYTE)(src)) < 0;
  1546.     bool flgo = ((BYTE)(dst)) < 0;
  1547.     bool flgn = ((BYTE)(newv)) < 0;
  1548.     regs.z = ((BYTE)(newv)) == 0;
  1549.     regs.v = (flgs == flgo) && (flgn != flgo);
  1550.     regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
  1551.     regs.n = flgn != 0;
  1552.     put_byte(dsta,newv);
  1553. }}}}}}
  1554. void op_640(UWORD opcode)
  1555. {
  1556.     ULONG dstreg = (opcode & 7) >> 0;
  1557. {{    WORD src = nextiword();
  1558. {    WORD dst = regs.d[dstreg];
  1559. {    ULONG newv = dst + src;
  1560. {    bool flgs = ((WORD)(src)) < 0;
  1561.     bool flgo = ((WORD)(dst)) < 0;
  1562.     bool flgn = ((WORD)(newv)) < 0;
  1563.     regs.z = ((WORD)(newv)) == 0;
  1564.     regs.v = (flgs == flgo) && (flgn != flgo);
  1565.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1566.     regs.n = flgn != 0;
  1567.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
  1568. }}}}}}
  1569. void op_650(UWORD opcode)
  1570. {
  1571.     ULONG dstreg = (opcode & 7) >> 0;
  1572. {{    WORD src = nextiword();
  1573. {    CPTR dsta = regs.a[dstreg];
  1574.     WORD dst = get_word(dsta);
  1575. {    ULONG newv = dst + src;
  1576. {    bool flgs = ((WORD)(src)) < 0;
  1577.     bool flgo = ((WORD)(dst)) < 0;
  1578.     bool flgn = ((WORD)(newv)) < 0;
  1579.     regs.z = ((WORD)(newv)) == 0;
  1580.     regs.v = (flgs == flgo) && (flgn != flgo);
  1581.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1582.     regs.n = flgn != 0;
  1583.     put_word(dsta,newv);
  1584. }}}}}}
  1585. void op_658(UWORD opcode)
  1586. {
  1587.     ULONG dstreg = (opcode & 7) >> 0;
  1588. {{    WORD src = nextiword();
  1589. {    CPTR dsta = regs.a[dstreg];
  1590.     WORD dst = get_word(dsta);
  1591. {    regs.a[dstreg] += 2;
  1592. {    ULONG newv = dst + src;
  1593. {    bool flgs = ((WORD)(src)) < 0;
  1594.     bool flgo = ((WORD)(dst)) < 0;
  1595.     bool flgn = ((WORD)(newv)) < 0;
  1596.     regs.z = ((WORD)(newv)) == 0;
  1597.     regs.v = (flgs == flgo) && (flgn != flgo);
  1598.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1599.     regs.n = flgn != 0;
  1600.     put_word(dsta,newv);
  1601. }}}}}}}
  1602. void op_660(UWORD opcode)
  1603. {
  1604.     ULONG dstreg = (opcode & 7) >> 0;
  1605. {{    WORD src = nextiword();
  1606. {    regs.a[dstreg] -= 2;
  1607. {    CPTR dsta = regs.a[dstreg];
  1608.     WORD dst = get_word(dsta);
  1609. {    ULONG newv = dst + src;
  1610. {    bool flgs = ((WORD)(src)) < 0;
  1611.     bool flgo = ((WORD)(dst)) < 0;
  1612.     bool flgn = ((WORD)(newv)) < 0;
  1613.     regs.z = ((WORD)(newv)) == 0;
  1614.     regs.v = (flgs == flgo) && (flgn != flgo);
  1615.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1616.     regs.n = flgn != 0;
  1617.     put_word(dsta,newv);
  1618. }}}}}}}
  1619. void op_668(UWORD opcode)
  1620. {
  1621.     ULONG dstreg = (opcode & 7) >> 0;
  1622. {{    WORD src = nextiword();
  1623. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1624.     WORD dst = get_word(dsta);
  1625. {    ULONG newv = dst + src;
  1626. {    bool flgs = ((WORD)(src)) < 0;
  1627.     bool flgo = ((WORD)(dst)) < 0;
  1628.     bool flgn = ((WORD)(newv)) < 0;
  1629.     regs.z = ((WORD)(newv)) == 0;
  1630.     regs.v = (flgs == flgo) && (flgn != flgo);
  1631.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1632.     regs.n = flgn != 0;
  1633.     put_word(dsta,newv);
  1634. }}}}}}
  1635. void op_670(UWORD opcode)
  1636. {
  1637.     ULONG dstreg = (opcode & 7) >> 0;
  1638. {{    WORD src = nextiword();
  1639. {    CPTR dsta = regs.a[dstreg];
  1640.     UWORD dstdp = nextiword();
  1641.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1642. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1643.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1644.     dsta += dstdpr;
  1645. {    WORD dst = get_word(dsta);
  1646. {    ULONG newv = dst + src;
  1647. {    bool flgs = ((WORD)(src)) < 0;
  1648.     bool flgo = ((WORD)(dst)) < 0;
  1649.     bool flgn = ((WORD)(newv)) < 0;
  1650.     regs.z = ((WORD)(newv)) == 0;
  1651.     regs.v = (flgs == flgo) && (flgn != flgo);
  1652.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1653.     regs.n = flgn != 0;
  1654.     put_word(dsta,newv);
  1655. }}}}}}}}
  1656. void op_678(UWORD opcode)
  1657. {
  1658. {{    WORD src = nextiword();
  1659. {    CPTR dsta = (LONG)(WORD)nextiword();
  1660.     WORD dst = get_word(dsta);
  1661. {    ULONG newv = dst + src;
  1662. {    bool flgs = ((WORD)(src)) < 0;
  1663.     bool flgo = ((WORD)(dst)) < 0;
  1664.     bool flgn = ((WORD)(newv)) < 0;
  1665.     regs.z = ((WORD)(newv)) == 0;
  1666.     regs.v = (flgs == flgo) && (flgn != flgo);
  1667.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1668.     regs.n = flgn != 0;
  1669.     put_word(dsta,newv);
  1670. }}}}}}
  1671. void op_679(UWORD opcode)
  1672. {
  1673. {{    WORD src = nextiword();
  1674. {    CPTR dsta = nextilong();
  1675.     WORD dst = get_word(dsta);
  1676. {    ULONG newv = dst + src;
  1677. {    bool flgs = ((WORD)(src)) < 0;
  1678.     bool flgo = ((WORD)(dst)) < 0;
  1679.     bool flgn = ((WORD)(newv)) < 0;
  1680.     regs.z = ((WORD)(newv)) == 0;
  1681.     regs.v = (flgs == flgo) && (flgn != flgo);
  1682.     regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
  1683.     regs.n = flgn != 0;
  1684.     put_word(dsta,newv);
  1685. }}}}}}
  1686. void op_680(UWORD opcode)
  1687. {
  1688.     ULONG dstreg = (opcode & 7) >> 0;
  1689. {{    LONG src = nextilong();
  1690. {    LONG dst = regs.d[dstreg];
  1691. {    ULONG newv = dst + src;
  1692. {    bool flgs = ((LONG)(src)) < 0;
  1693.     bool flgo = ((LONG)(dst)) < 0;
  1694.     bool flgn = ((LONG)(newv)) < 0;
  1695.     regs.z = ((LONG)(newv)) == 0;
  1696.     regs.v = (flgs == flgo) && (flgn != flgo);
  1697.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1698.     regs.n = flgn != 0;
  1699.     regs.d[dstreg] = (newv);
  1700. }}}}}}
  1701. void op_690(UWORD opcode)
  1702. {
  1703.     ULONG dstreg = (opcode & 7) >> 0;
  1704. {{    LONG src = nextilong();
  1705. {    CPTR dsta = regs.a[dstreg];
  1706.     LONG dst = get_long(dsta);
  1707. {    ULONG newv = dst + src;
  1708. {    bool flgs = ((LONG)(src)) < 0;
  1709.     bool flgo = ((LONG)(dst)) < 0;
  1710.     bool flgn = ((LONG)(newv)) < 0;
  1711.     regs.z = ((LONG)(newv)) == 0;
  1712.     regs.v = (flgs == flgo) && (flgn != flgo);
  1713.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1714.     regs.n = flgn != 0;
  1715.     put_long(dsta,newv);
  1716. }}}}}}
  1717. void op_698(UWORD opcode)
  1718. {
  1719.     ULONG dstreg = (opcode & 7) >> 0;
  1720. {{    LONG src = nextilong();
  1721. {    CPTR dsta = regs.a[dstreg];
  1722.     LONG dst = get_long(dsta);
  1723. {    regs.a[dstreg] += 4;
  1724. {    ULONG newv = dst + src;
  1725. {    bool flgs = ((LONG)(src)) < 0;
  1726.     bool flgo = ((LONG)(dst)) < 0;
  1727.     bool flgn = ((LONG)(newv)) < 0;
  1728.     regs.z = ((LONG)(newv)) == 0;
  1729.     regs.v = (flgs == flgo) && (flgn != flgo);
  1730.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1731.     regs.n = flgn != 0;
  1732.     put_long(dsta,newv);
  1733. }}}}}}}
  1734. void op_6a0(UWORD opcode)
  1735. {
  1736.     ULONG dstreg = (opcode & 7) >> 0;
  1737. {{    LONG src = nextilong();
  1738. {    regs.a[dstreg] -= 4;
  1739. {    CPTR dsta = regs.a[dstreg];
  1740.     LONG dst = get_long(dsta);
  1741. {    ULONG newv = dst + src;
  1742. {    bool flgs = ((LONG)(src)) < 0;
  1743.     bool flgo = ((LONG)(dst)) < 0;
  1744.     bool flgn = ((LONG)(newv)) < 0;
  1745.     regs.z = ((LONG)(newv)) == 0;
  1746.     regs.v = (flgs == flgo) && (flgn != flgo);
  1747.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1748.     regs.n = flgn != 0;
  1749.     put_long(dsta,newv);
  1750. }}}}}}}
  1751. void op_6a8(UWORD opcode)
  1752. {
  1753.     ULONG dstreg = (opcode & 7) >> 0;
  1754. {{    LONG src = nextilong();
  1755. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1756.     LONG dst = get_long(dsta);
  1757. {    ULONG newv = dst + src;
  1758. {    bool flgs = ((LONG)(src)) < 0;
  1759.     bool flgo = ((LONG)(dst)) < 0;
  1760.     bool flgn = ((LONG)(newv)) < 0;
  1761.     regs.z = ((LONG)(newv)) == 0;
  1762.     regs.v = (flgs == flgo) && (flgn != flgo);
  1763.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1764.     regs.n = flgn != 0;
  1765.     put_long(dsta,newv);
  1766. }}}}}}
  1767. void op_6b0(UWORD opcode)
  1768. {
  1769.     ULONG dstreg = (opcode & 7) >> 0;
  1770. {{    LONG src = nextilong();
  1771. {    CPTR dsta = regs.a[dstreg];
  1772.     UWORD dstdp = nextiword();
  1773.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1774. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1775.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1776.     dsta += dstdpr;
  1777. {    LONG dst = get_long(dsta);
  1778. {    ULONG newv = dst + src;
  1779. {    bool flgs = ((LONG)(src)) < 0;
  1780.     bool flgo = ((LONG)(dst)) < 0;
  1781.     bool flgn = ((LONG)(newv)) < 0;
  1782.     regs.z = ((LONG)(newv)) == 0;
  1783.     regs.v = (flgs == flgo) && (flgn != flgo);
  1784.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1785.     regs.n = flgn != 0;
  1786.     put_long(dsta,newv);
  1787. }}}}}}}}
  1788. void op_6b8(UWORD opcode)
  1789. {
  1790. {{    LONG src = nextilong();
  1791. {    CPTR dsta = (LONG)(WORD)nextiword();
  1792.     LONG dst = get_long(dsta);
  1793. {    ULONG newv = dst + src;
  1794. {    bool flgs = ((LONG)(src)) < 0;
  1795.     bool flgo = ((LONG)(dst)) < 0;
  1796.     bool flgn = ((LONG)(newv)) < 0;
  1797.     regs.z = ((LONG)(newv)) == 0;
  1798.     regs.v = (flgs == flgo) && (flgn != flgo);
  1799.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1800.     regs.n = flgn != 0;
  1801.     put_long(dsta,newv);
  1802. }}}}}}
  1803. void op_6b9(UWORD opcode)
  1804. {
  1805. {{    LONG src = nextilong();
  1806. {    CPTR dsta = nextilong();
  1807.     LONG dst = get_long(dsta);
  1808. {    ULONG newv = dst + src;
  1809. {    bool flgs = ((LONG)(src)) < 0;
  1810.     bool flgo = ((LONG)(dst)) < 0;
  1811.     bool flgn = ((LONG)(newv)) < 0;
  1812.     regs.z = ((LONG)(newv)) == 0;
  1813.     regs.v = (flgs == flgo) && (flgn != flgo);
  1814.     regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
  1815.     regs.n = flgn != 0;
  1816.     put_long(dsta,newv);
  1817. }}}}}}
  1818. void op_800(UWORD opcode)
  1819. {
  1820.     ULONG dstreg = (opcode & 7) >> 0;
  1821. {{    WORD src = nextiword();
  1822. {    LONG dst = regs.d[dstreg];
  1823.     src &= 31;
  1824.     regs.z = !(dst & (1 << src));
  1825. }}}}
  1826. void op_810(UWORD opcode)
  1827. {
  1828.     ULONG dstreg = (opcode & 7) >> 0;
  1829. {{    WORD src = nextiword();
  1830. {    CPTR dsta = regs.a[dstreg];
  1831.     BYTE dst = get_byte(dsta);
  1832.     src &= 7;
  1833.     regs.z = !(dst & (1 << src));
  1834. }}}}
  1835. void op_818(UWORD opcode)
  1836. {
  1837.     ULONG dstreg = (opcode & 7) >> 0;
  1838. {{    WORD src = nextiword();
  1839. {    CPTR dsta = regs.a[dstreg];
  1840.     BYTE dst = get_byte(dsta);
  1841. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  1842.     src &= 7;
  1843.     regs.z = !(dst & (1 << src));
  1844. }}}}}
  1845. void op_820(UWORD opcode)
  1846. {
  1847.     ULONG dstreg = (opcode & 7) >> 0;
  1848. {{    WORD src = nextiword();
  1849. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  1850. {    CPTR dsta = regs.a[dstreg];
  1851.     BYTE dst = get_byte(dsta);
  1852.     src &= 7;
  1853.     regs.z = !(dst & (1 << src));
  1854. }}}}}
  1855. void op_828(UWORD opcode)
  1856. {
  1857.     ULONG dstreg = (opcode & 7) >> 0;
  1858. {{    WORD src = nextiword();
  1859. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1860.     BYTE dst = get_byte(dsta);
  1861.     src &= 7;
  1862.     regs.z = !(dst & (1 << src));
  1863. }}}}
  1864. void op_830(UWORD opcode)
  1865. {
  1866.     ULONG dstreg = (opcode & 7) >> 0;
  1867. {{    WORD src = nextiword();
  1868. {    CPTR dsta = regs.a[dstreg];
  1869.     UWORD dstdp = nextiword();
  1870.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1871. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1872.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1873.     dsta += dstdpr;
  1874. {    BYTE dst = get_byte(dsta);
  1875.     src &= 7;
  1876.     regs.z = !(dst & (1 << src));
  1877. }}}}}}
  1878. void op_838(UWORD opcode)
  1879. {
  1880. {{    WORD src = nextiword();
  1881. {    CPTR dsta = (LONG)(WORD)nextiword();
  1882.     BYTE dst = get_byte(dsta);
  1883.     src &= 7;
  1884.     regs.z = !(dst & (1 << src));
  1885. }}}}
  1886. void op_839(UWORD opcode)
  1887. {
  1888. {{    WORD src = nextiword();
  1889. {    CPTR dsta = nextilong();
  1890.     BYTE dst = get_byte(dsta);
  1891.     src &= 7;
  1892.     regs.z = !(dst & (1 << src));
  1893. }}}}
  1894. void op_83a(UWORD opcode)
  1895. {
  1896.     ULONG dstreg = 2;
  1897. {{    WORD src = nextiword();
  1898. {    CPTR dsta = m68k_getpc();
  1899.     dsta += (LONG)(WORD)nextiword();
  1900. {    BYTE dst = get_byte(dsta);
  1901.     src &= 7;
  1902.     regs.z = !(dst & (1 << src));
  1903. }}}}}
  1904. void op_83b(UWORD opcode)
  1905. {
  1906.     ULONG dstreg = 3;
  1907. {{    WORD src = nextiword();
  1908. {    CPTR dsta = m68k_getpc();
  1909.     UWORD dstdp = nextiword();
  1910.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1911. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1912.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1913.     dsta += dstdpr;
  1914. {    BYTE dst = get_byte(dsta);
  1915.     src &= 7;
  1916.     regs.z = !(dst & (1 << src));
  1917. }}}}}}
  1918. void op_840(UWORD opcode)
  1919. {
  1920.     ULONG dstreg = (opcode & 7) >> 0;
  1921. {{    WORD src = nextiword();
  1922. {    LONG dst = regs.d[dstreg];
  1923.     src &= 31;
  1924.     regs.z = !(dst & (1 << src));
  1925.     dst ^= (1 << src);
  1926.     regs.d[dstreg] = (dst);
  1927. }}}}
  1928. void op_850(UWORD opcode)
  1929. {
  1930.     ULONG dstreg = (opcode & 7) >> 0;
  1931. {{    WORD src = nextiword();
  1932. {    CPTR dsta = regs.a[dstreg];
  1933.     BYTE dst = get_byte(dsta);
  1934.     src &= 7;
  1935.     regs.z = !(dst & (1 << src));
  1936.     dst ^= (1 << src);
  1937.     put_byte(dsta,dst);
  1938. }}}}
  1939. void op_858(UWORD opcode)
  1940. {
  1941.     ULONG dstreg = (opcode & 7) >> 0;
  1942. {{    WORD src = nextiword();
  1943. {    CPTR dsta = regs.a[dstreg];
  1944.     BYTE dst = get_byte(dsta);
  1945. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  1946.     src &= 7;
  1947.     regs.z = !(dst & (1 << src));
  1948.     dst ^= (1 << src);
  1949.     put_byte(dsta,dst);
  1950. }}}}}
  1951. void op_860(UWORD opcode)
  1952. {
  1953.     ULONG dstreg = (opcode & 7) >> 0;
  1954. {{    WORD src = nextiword();
  1955. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  1956. {    CPTR dsta = regs.a[dstreg];
  1957.     BYTE dst = get_byte(dsta);
  1958.     src &= 7;
  1959.     regs.z = !(dst & (1 << src));
  1960.     dst ^= (1 << src);
  1961.     put_byte(dsta,dst);
  1962. }}}}}
  1963. void op_868(UWORD opcode)
  1964. {
  1965.     ULONG dstreg = (opcode & 7) >> 0;
  1966. {{    WORD src = nextiword();
  1967. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  1968.     BYTE dst = get_byte(dsta);
  1969.     src &= 7;
  1970.     regs.z = !(dst & (1 << src));
  1971.     dst ^= (1 << src);
  1972.     put_byte(dsta,dst);
  1973. }}}}
  1974. void op_870(UWORD opcode)
  1975. {
  1976.     ULONG dstreg = (opcode & 7) >> 0;
  1977. {{    WORD src = nextiword();
  1978. {    CPTR dsta = regs.a[dstreg];
  1979.     UWORD dstdp = nextiword();
  1980.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  1981. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  1982.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  1983.     dsta += dstdpr;
  1984. {    BYTE dst = get_byte(dsta);
  1985.     src &= 7;
  1986.     regs.z = !(dst & (1 << src));
  1987.     dst ^= (1 << src);
  1988.     put_byte(dsta,dst);
  1989. }}}}}}
  1990. void op_878(UWORD opcode)
  1991. {
  1992. {{    WORD src = nextiword();
  1993. {    CPTR dsta = (LONG)(WORD)nextiword();
  1994.     BYTE dst = get_byte(dsta);
  1995.     src &= 7;
  1996.     regs.z = !(dst & (1 << src));
  1997.     dst ^= (1 << src);
  1998.     put_byte(dsta,dst);
  1999. }}}}
  2000. void op_879(UWORD opcode)
  2001. {
  2002. {{    WORD src = nextiword();
  2003. {    CPTR dsta = nextilong();
  2004.     BYTE dst = get_byte(dsta);
  2005.     src &= 7;
  2006.     regs.z = !(dst & (1 << src));
  2007.     dst ^= (1 << src);
  2008.     put_byte(dsta,dst);
  2009. }}}}
  2010. void op_87a(UWORD opcode)
  2011. {
  2012.     ULONG dstreg = 2;
  2013. {{    WORD src = nextiword();
  2014. {    CPTR dsta = m68k_getpc();
  2015.     dsta += (LONG)(WORD)nextiword();
  2016. {    BYTE dst = get_byte(dsta);
  2017.     src &= 7;
  2018.     regs.z = !(dst & (1 << src));
  2019.     dst ^= (1 << src);
  2020.     put_byte(dsta,dst);
  2021. }}}}}
  2022. void op_87b(UWORD opcode)
  2023. {
  2024.     ULONG dstreg = 3;
  2025. {{    WORD src = nextiword();
  2026. {    CPTR dsta = m68k_getpc();
  2027.     UWORD dstdp = nextiword();
  2028.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2029. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2030.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2031.     dsta += dstdpr;
  2032. {    BYTE dst = get_byte(dsta);
  2033.     src &= 7;
  2034.     regs.z = !(dst & (1 << src));
  2035.     dst ^= (1 << src);
  2036.     put_byte(dsta,dst);
  2037. }}}}}}
  2038. void op_880(UWORD opcode)
  2039. {
  2040.     ULONG dstreg = (opcode & 7) >> 0;
  2041. {{    WORD src = nextiword();
  2042. {    LONG dst = regs.d[dstreg];
  2043.     src &= 31;
  2044.     regs.z = !(dst & (1 << src));
  2045.     dst &= ~(1 << src);
  2046.     regs.d[dstreg] = (dst);
  2047. }}}}
  2048. void op_890(UWORD opcode)
  2049. {
  2050.     ULONG dstreg = (opcode & 7) >> 0;
  2051. {{    WORD src = nextiword();
  2052. {    CPTR dsta = regs.a[dstreg];
  2053.     BYTE dst = get_byte(dsta);
  2054.     src &= 7;
  2055.     regs.z = !(dst & (1 << src));
  2056.     dst &= ~(1 << src);
  2057.     put_byte(dsta,dst);
  2058. }}}}
  2059. void op_898(UWORD opcode)
  2060. {
  2061.     ULONG dstreg = (opcode & 7) >> 0;
  2062. {{    WORD src = nextiword();
  2063. {    CPTR dsta = regs.a[dstreg];
  2064.     BYTE dst = get_byte(dsta);
  2065. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  2066.     src &= 7;
  2067.     regs.z = !(dst & (1 << src));
  2068.     dst &= ~(1 << src);
  2069.     put_byte(dsta,dst);
  2070. }}}}}
  2071. void op_8a0(UWORD opcode)
  2072. {
  2073.     ULONG dstreg = (opcode & 7) >> 0;
  2074. {{    WORD src = nextiword();
  2075. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  2076. {    CPTR dsta = regs.a[dstreg];
  2077.     BYTE dst = get_byte(dsta);
  2078.     src &= 7;
  2079.     regs.z = !(dst & (1 << src));
  2080.     dst &= ~(1 << src);
  2081.     put_byte(dsta,dst);
  2082. }}}}}
  2083. void op_8a8(UWORD opcode)
  2084. {
  2085.     ULONG dstreg = (opcode & 7) >> 0;
  2086. {{    WORD src = nextiword();
  2087. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2088.     BYTE dst = get_byte(dsta);
  2089.     src &= 7;
  2090.     regs.z = !(dst & (1 << src));
  2091.     dst &= ~(1 << src);
  2092.     put_byte(dsta,dst);
  2093. }}}}
  2094. void op_8b0(UWORD opcode)
  2095. {
  2096.     ULONG dstreg = (opcode & 7) >> 0;
  2097. {{    WORD src = nextiword();
  2098. {    CPTR dsta = regs.a[dstreg];
  2099.     UWORD dstdp = nextiword();
  2100.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2101. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2102.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2103.     dsta += dstdpr;
  2104. {    BYTE dst = get_byte(dsta);
  2105.     src &= 7;
  2106.     regs.z = !(dst & (1 << src));
  2107.     dst &= ~(1 << src);
  2108.     put_byte(dsta,dst);
  2109. }}}}}}
  2110. void op_8b8(UWORD opcode)
  2111. {
  2112. {{    WORD src = nextiword();
  2113. {    CPTR dsta = (LONG)(WORD)nextiword();
  2114.     BYTE dst = get_byte(dsta);
  2115.     src &= 7;
  2116.     regs.z = !(dst & (1 << src));
  2117.     dst &= ~(1 << src);
  2118.     put_byte(dsta,dst);
  2119. }}}}
  2120. void op_8b9(UWORD opcode)
  2121. {
  2122. {{    WORD src = nextiword();
  2123. {    CPTR dsta = nextilong();
  2124.     BYTE dst = get_byte(dsta);
  2125.     src &= 7;
  2126.     regs.z = !(dst & (1 << src));
  2127.     dst &= ~(1 << src);
  2128.     put_byte(dsta,dst);
  2129. }}}}
  2130. void op_8ba(UWORD opcode)
  2131. {
  2132.     ULONG dstreg = 2;
  2133. {{    WORD src = nextiword();
  2134. {    CPTR dsta = m68k_getpc();
  2135.     dsta += (LONG)(WORD)nextiword();
  2136. {    BYTE dst = get_byte(dsta);
  2137.     src &= 7;
  2138.     regs.z = !(dst & (1 << src));
  2139.     dst &= ~(1 << src);
  2140.     put_byte(dsta,dst);
  2141. }}}}}
  2142. void op_8bb(UWORD opcode)
  2143. {
  2144.     ULONG dstreg = 3;
  2145. {{    WORD src = nextiword();
  2146. {    CPTR dsta = m68k_getpc();
  2147.     UWORD dstdp = nextiword();
  2148.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2149. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2150.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2151.     dsta += dstdpr;
  2152. {    BYTE dst = get_byte(dsta);
  2153.     src &= 7;
  2154.     regs.z = !(dst & (1 << src));
  2155.     dst &= ~(1 << src);
  2156.     put_byte(dsta,dst);
  2157. }}}}}}
  2158. void op_8c0(UWORD opcode)
  2159. {
  2160.     ULONG dstreg = (opcode & 7) >> 0;
  2161. {{    WORD src = nextiword();
  2162. {    LONG dst = regs.d[dstreg];
  2163.     src &= 31;
  2164.     regs.z = !(dst & (1 << src));
  2165.     dst |= (1 << src);
  2166.     regs.d[dstreg] = (dst);
  2167. }}}}
  2168. void op_8d0(UWORD opcode)
  2169. {
  2170.     ULONG dstreg = (opcode & 7) >> 0;
  2171. {{    WORD src = nextiword();
  2172. {    CPTR dsta = regs.a[dstreg];
  2173.     BYTE dst = get_byte(dsta);
  2174.     src &= 7;
  2175.     regs.z = !(dst & (1 << src));
  2176.     dst |= (1 << src);
  2177.     put_byte(dsta,dst);
  2178. }}}}
  2179. void op_8d8(UWORD opcode)
  2180. {
  2181.     ULONG dstreg = (opcode & 7) >> 0;
  2182. {{    WORD src = nextiword();
  2183. {    CPTR dsta = regs.a[dstreg];
  2184.     BYTE dst = get_byte(dsta);
  2185. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  2186.     src &= 7;
  2187.     regs.z = !(dst & (1 << src));
  2188.     dst |= (1 << src);
  2189.     put_byte(dsta,dst);
  2190. }}}}}
  2191. void op_8e0(UWORD opcode)
  2192. {
  2193.     ULONG dstreg = (opcode & 7) >> 0;
  2194. {{    WORD src = nextiword();
  2195. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  2196. {    CPTR dsta = regs.a[dstreg];
  2197.     BYTE dst = get_byte(dsta);
  2198.     src &= 7;
  2199.     regs.z = !(dst & (1 << src));
  2200.     dst |= (1 << src);
  2201.     put_byte(dsta,dst);
  2202. }}}}}
  2203. void op_8e8(UWORD opcode)
  2204. {
  2205.     ULONG dstreg = (opcode & 7) >> 0;
  2206. {{    WORD src = nextiword();
  2207. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2208.     BYTE dst = get_byte(dsta);
  2209.     src &= 7;
  2210.     regs.z = !(dst & (1 << src));
  2211.     dst |= (1 << src);
  2212.     put_byte(dsta,dst);
  2213. }}}}
  2214. void op_8f0(UWORD opcode)
  2215. {
  2216.     ULONG dstreg = (opcode & 7) >> 0;
  2217. {{    WORD src = nextiword();
  2218. {    CPTR dsta = regs.a[dstreg];
  2219.     UWORD dstdp = nextiword();
  2220.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2221. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2222.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2223.     dsta += dstdpr;
  2224. {    BYTE dst = get_byte(dsta);
  2225.     src &= 7;
  2226.     regs.z = !(dst & (1 << src));
  2227.     dst |= (1 << src);
  2228.     put_byte(dsta,dst);
  2229. }}}}}}
  2230. void op_8f8(UWORD opcode)
  2231. {
  2232. {{    WORD src = nextiword();
  2233. {    CPTR dsta = (LONG)(WORD)nextiword();
  2234.     BYTE dst = get_byte(dsta);
  2235.     src &= 7;
  2236.     regs.z = !(dst & (1 << src));
  2237.     dst |= (1 << src);
  2238.     put_byte(dsta,dst);
  2239. }}}}
  2240. void op_8f9(UWORD opcode)
  2241. {
  2242. {{    WORD src = nextiword();
  2243. {    CPTR dsta = nextilong();
  2244.     BYTE dst = get_byte(dsta);
  2245.     src &= 7;
  2246.     regs.z = !(dst & (1 << src));
  2247.     dst |= (1 << src);
  2248.     put_byte(dsta,dst);
  2249. }}}}
  2250. void op_8fa(UWORD opcode)
  2251. {
  2252.     ULONG dstreg = 2;
  2253. {{    WORD src = nextiword();
  2254. {    CPTR dsta = m68k_getpc();
  2255.     dsta += (LONG)(WORD)nextiword();
  2256. {    BYTE dst = get_byte(dsta);
  2257.     src &= 7;
  2258.     regs.z = !(dst & (1 << src));
  2259.     dst |= (1 << src);
  2260.     put_byte(dsta,dst);
  2261. }}}}}
  2262. void op_8fb(UWORD opcode)
  2263. {
  2264.     ULONG dstreg = 3;
  2265. {{    WORD src = nextiword();
  2266. {    CPTR dsta = m68k_getpc();
  2267.     UWORD dstdp = nextiword();
  2268.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2269. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2270.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2271.     dsta += dstdpr;
  2272. {    BYTE dst = get_byte(dsta);
  2273.     src &= 7;
  2274.     regs.z = !(dst & (1 << src));
  2275.     dst |= (1 << src);
  2276.     put_byte(dsta,dst);
  2277. }}}}}}
  2278. void op_a00(UWORD opcode)
  2279. {
  2280.     ULONG dstreg = (opcode & 7) >> 0;
  2281. {{    BYTE src = nextiword();
  2282. {    BYTE dst = regs.d[dstreg];
  2283.     src ^= dst;
  2284.     regs.v = regs.c = 0;
  2285.     regs.z = ((BYTE)(src)) == 0;
  2286.     regs.n = ((BYTE)(src)) < 0;
  2287.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  2288. }}}}
  2289. void op_a10(UWORD opcode)
  2290. {
  2291.     ULONG dstreg = (opcode & 7) >> 0;
  2292. {{    BYTE src = nextiword();
  2293. {    CPTR dsta = regs.a[dstreg];
  2294.     BYTE dst = get_byte(dsta);
  2295.     src ^= dst;
  2296.     regs.v = regs.c = 0;
  2297.     regs.z = ((BYTE)(src)) == 0;
  2298.     regs.n = ((BYTE)(src)) < 0;
  2299.     put_byte(dsta,src);
  2300. }}}}
  2301. void op_a18(UWORD opcode)
  2302. {
  2303.     ULONG dstreg = (opcode & 7) >> 0;
  2304. {{    BYTE src = nextiword();
  2305. {    CPTR dsta = regs.a[dstreg];
  2306.     BYTE dst = get_byte(dsta);
  2307. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  2308.     src ^= dst;
  2309.     regs.v = regs.c = 0;
  2310.     regs.z = ((BYTE)(src)) == 0;
  2311.     regs.n = ((BYTE)(src)) < 0;
  2312.     put_byte(dsta,src);
  2313. }}}}}
  2314. void op_a20(UWORD opcode)
  2315. {
  2316.     ULONG dstreg = (opcode & 7) >> 0;
  2317. {{    BYTE src = nextiword();
  2318. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  2319. {    CPTR dsta = regs.a[dstreg];
  2320.     BYTE dst = get_byte(dsta);
  2321.     src ^= dst;
  2322.     regs.v = regs.c = 0;
  2323.     regs.z = ((BYTE)(src)) == 0;
  2324.     regs.n = ((BYTE)(src)) < 0;
  2325.     put_byte(dsta,src);
  2326. }}}}}
  2327. void op_a28(UWORD opcode)
  2328. {
  2329.     ULONG dstreg = (opcode & 7) >> 0;
  2330. {{    BYTE src = nextiword();
  2331. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2332.     BYTE dst = get_byte(dsta);
  2333.     src ^= dst;
  2334.     regs.v = regs.c = 0;
  2335.     regs.z = ((BYTE)(src)) == 0;
  2336.     regs.n = ((BYTE)(src)) < 0;
  2337.     put_byte(dsta,src);
  2338. }}}}
  2339. void op_a30(UWORD opcode)
  2340. {
  2341.     ULONG dstreg = (opcode & 7) >> 0;
  2342. {{    BYTE src = nextiword();
  2343. {    CPTR dsta = regs.a[dstreg];
  2344.     UWORD dstdp = nextiword();
  2345.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2346. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2347.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2348.     dsta += dstdpr;
  2349. {    BYTE dst = get_byte(dsta);
  2350.     src ^= dst;
  2351.     regs.v = regs.c = 0;
  2352.     regs.z = ((BYTE)(src)) == 0;
  2353.     regs.n = ((BYTE)(src)) < 0;
  2354.     put_byte(dsta,src);
  2355. }}}}}}
  2356. void op_a38(UWORD opcode)
  2357. {
  2358. {{    BYTE src = nextiword();
  2359. {    CPTR dsta = (LONG)(WORD)nextiword();
  2360.     BYTE dst = get_byte(dsta);
  2361.     src ^= dst;
  2362.     regs.v = regs.c = 0;
  2363.     regs.z = ((BYTE)(src)) == 0;
  2364.     regs.n = ((BYTE)(src)) < 0;
  2365.     put_byte(dsta,src);
  2366. }}}}
  2367. void op_a39(UWORD opcode)
  2368. {
  2369. {{    BYTE src = nextiword();
  2370. {    CPTR dsta = nextilong();
  2371.     BYTE dst = get_byte(dsta);
  2372.     src ^= dst;
  2373.     regs.v = regs.c = 0;
  2374.     regs.z = ((BYTE)(src)) == 0;
  2375.     regs.n = ((BYTE)(src)) < 0;
  2376.     put_byte(dsta,src);
  2377. }}}}
  2378. void op_a3c(UWORD opcode)
  2379. {
  2380. {{    MakeSR();
  2381. {    WORD src = nextiword();
  2382.     src &= 0xFF;
  2383.     regs.sr ^= src;
  2384.     MakeFromSR();
  2385. }}}}
  2386. void op_a40(UWORD opcode)
  2387. {
  2388.     ULONG dstreg = (opcode & 7) >> 0;
  2389. {{    WORD src = nextiword();
  2390. {    WORD dst = regs.d[dstreg];
  2391.     src ^= dst;
  2392.     regs.v = regs.c = 0;
  2393.     regs.z = ((WORD)(src)) == 0;
  2394.     regs.n = ((WORD)(src)) < 0;
  2395.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  2396. }}}}
  2397. void op_a50(UWORD opcode)
  2398. {
  2399.     ULONG dstreg = (opcode & 7) >> 0;
  2400. {{    WORD src = nextiword();
  2401. {    CPTR dsta = regs.a[dstreg];
  2402.     WORD dst = get_word(dsta);
  2403.     src ^= dst;
  2404.     regs.v = regs.c = 0;
  2405.     regs.z = ((WORD)(src)) == 0;
  2406.     regs.n = ((WORD)(src)) < 0;
  2407.     put_word(dsta,src);
  2408. }}}}
  2409. void op_a58(UWORD opcode)
  2410. {
  2411.     ULONG dstreg = (opcode & 7) >> 0;
  2412. {{    WORD src = nextiword();
  2413. {    CPTR dsta = regs.a[dstreg];
  2414.     WORD dst = get_word(dsta);
  2415. {    regs.a[dstreg] += 2;
  2416.     src ^= dst;
  2417.     regs.v = regs.c = 0;
  2418.     regs.z = ((WORD)(src)) == 0;
  2419.     regs.n = ((WORD)(src)) < 0;
  2420.     put_word(dsta,src);
  2421. }}}}}
  2422. void op_a60(UWORD opcode)
  2423. {
  2424.     ULONG dstreg = (opcode & 7) >> 0;
  2425. {{    WORD src = nextiword();
  2426. {    regs.a[dstreg] -= 2;
  2427. {    CPTR dsta = regs.a[dstreg];
  2428.     WORD dst = get_word(dsta);
  2429.     src ^= dst;
  2430.     regs.v = regs.c = 0;
  2431.     regs.z = ((WORD)(src)) == 0;
  2432.     regs.n = ((WORD)(src)) < 0;
  2433.     put_word(dsta,src);
  2434. }}}}}
  2435. void op_a68(UWORD opcode)
  2436. {
  2437.     ULONG dstreg = (opcode & 7) >> 0;
  2438. {{    WORD src = nextiword();
  2439. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2440.     WORD dst = get_word(dsta);
  2441.     src ^= dst;
  2442.     regs.v = regs.c = 0;
  2443.     regs.z = ((WORD)(src)) == 0;
  2444.     regs.n = ((WORD)(src)) < 0;
  2445.     put_word(dsta,src);
  2446. }}}}
  2447. void op_a70(UWORD opcode)
  2448. {
  2449.     ULONG dstreg = (opcode & 7) >> 0;
  2450. {{    WORD src = nextiword();
  2451. {    CPTR dsta = regs.a[dstreg];
  2452.     UWORD dstdp = nextiword();
  2453.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2454. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2455.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2456.     dsta += dstdpr;
  2457. {    WORD dst = get_word(dsta);
  2458.     src ^= dst;
  2459.     regs.v = regs.c = 0;
  2460.     regs.z = ((WORD)(src)) == 0;
  2461.     regs.n = ((WORD)(src)) < 0;
  2462.     put_word(dsta,src);
  2463. }}}}}}
  2464. void op_a78(UWORD opcode)
  2465. {
  2466. {{    WORD src = nextiword();
  2467. {    CPTR dsta = (LONG)(WORD)nextiword();
  2468.     WORD dst = get_word(dsta);
  2469.     src ^= dst;
  2470.     regs.v = regs.c = 0;
  2471.     regs.z = ((WORD)(src)) == 0;
  2472.     regs.n = ((WORD)(src)) < 0;
  2473.     put_word(dsta,src);
  2474. }}}}
  2475. void op_a79(UWORD opcode)
  2476. {
  2477. {{    WORD src = nextiword();
  2478. {    CPTR dsta = nextilong();
  2479.     WORD dst = get_word(dsta);
  2480.     src ^= dst;
  2481.     regs.v = regs.c = 0;
  2482.     regs.z = ((WORD)(src)) == 0;
  2483.     regs.n = ((WORD)(src)) < 0;
  2484.     put_word(dsta,src);
  2485. }}}}
  2486. void op_a7c(UWORD opcode)
  2487. {
  2488. {    if (!regs.s) { regs.pc_p--; Exception(8); } else
  2489. {    MakeSR();
  2490. {    WORD src = nextiword();
  2491.     regs.sr ^= src;
  2492.     MakeFromSR();
  2493. }}}}
  2494. void op_a80(UWORD opcode)
  2495. {
  2496.     ULONG dstreg = (opcode & 7) >> 0;
  2497. {{    LONG src = nextilong();
  2498. {    LONG dst = regs.d[dstreg];
  2499.     src ^= dst;
  2500.     regs.v = regs.c = 0;
  2501.     regs.z = ((LONG)(src)) == 0;
  2502.     regs.n = ((LONG)(src)) < 0;
  2503.     regs.d[dstreg] = (src);
  2504. }}}}
  2505. void op_a90(UWORD opcode)
  2506. {
  2507.     ULONG dstreg = (opcode & 7) >> 0;
  2508. {{    LONG src = nextilong();
  2509. {    CPTR dsta = regs.a[dstreg];
  2510.     LONG dst = get_long(dsta);
  2511.     src ^= dst;
  2512.     regs.v = regs.c = 0;
  2513.     regs.z = ((LONG)(src)) == 0;
  2514.     regs.n = ((LONG)(src)) < 0;
  2515.     put_long(dsta,src);
  2516. }}}}
  2517. void op_a98(UWORD opcode)
  2518. {
  2519.     ULONG dstreg = (opcode & 7) >> 0;
  2520. {{    LONG src = nextilong();
  2521. {    CPTR dsta = regs.a[dstreg];
  2522.     LONG dst = get_long(dsta);
  2523. {    regs.a[dstreg] += 4;
  2524.     src ^= dst;
  2525.     regs.v = regs.c = 0;
  2526.     regs.z = ((LONG)(src)) == 0;
  2527.     regs.n = ((LONG)(src)) < 0;
  2528.     put_long(dsta,src);
  2529. }}}}}
  2530. void op_aa0(UWORD opcode)
  2531. {
  2532.     ULONG dstreg = (opcode & 7) >> 0;
  2533. {{    LONG src = nextilong();
  2534. {    regs.a[dstreg] -= 4;
  2535. {    CPTR dsta = regs.a[dstreg];
  2536.     LONG dst = get_long(dsta);
  2537.     src ^= dst;
  2538.     regs.v = regs.c = 0;
  2539.     regs.z = ((LONG)(src)) == 0;
  2540.     regs.n = ((LONG)(src)) < 0;
  2541.     put_long(dsta,src);
  2542. }}}}}
  2543. void op_aa8(UWORD opcode)
  2544. {
  2545.     ULONG dstreg = (opcode & 7) >> 0;
  2546. {{    LONG src = nextilong();
  2547. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2548.     LONG dst = get_long(dsta);
  2549.     src ^= dst;
  2550.     regs.v = regs.c = 0;
  2551.     regs.z = ((LONG)(src)) == 0;
  2552.     regs.n = ((LONG)(src)) < 0;
  2553.     put_long(dsta,src);
  2554. }}}}
  2555. void op_ab0(UWORD opcode)
  2556. {
  2557.     ULONG dstreg = (opcode & 7) >> 0;
  2558. {{    LONG src = nextilong();
  2559. {    CPTR dsta = regs.a[dstreg];
  2560.     UWORD dstdp = nextiword();
  2561.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2562. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2563.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2564.     dsta += dstdpr;
  2565. {    LONG dst = get_long(dsta);
  2566.     src ^= dst;
  2567.     regs.v = regs.c = 0;
  2568.     regs.z = ((LONG)(src)) == 0;
  2569.     regs.n = ((LONG)(src)) < 0;
  2570.     put_long(dsta,src);
  2571. }}}}}}
  2572. void op_ab8(UWORD opcode)
  2573. {
  2574. {{    LONG src = nextilong();
  2575. {    CPTR dsta = (LONG)(WORD)nextiword();
  2576.     LONG dst = get_long(dsta);
  2577.     src ^= dst;
  2578.     regs.v = regs.c = 0;
  2579.     regs.z = ((LONG)(src)) == 0;
  2580.     regs.n = ((LONG)(src)) < 0;
  2581.     put_long(dsta,src);
  2582. }}}}
  2583. void op_ab9(UWORD opcode)
  2584. {
  2585. {{    LONG src = nextilong();
  2586. {    CPTR dsta = nextilong();
  2587.     LONG dst = get_long(dsta);
  2588.     src ^= dst;
  2589.     regs.v = regs.c = 0;
  2590.     regs.z = ((LONG)(src)) == 0;
  2591.     regs.n = ((LONG)(src)) < 0;
  2592.     put_long(dsta,src);
  2593. }}}}
  2594. void op_c00(UWORD opcode)
  2595. {
  2596.     ULONG dstreg = (opcode & 7) >> 0;
  2597. {{    BYTE src = nextiword();
  2598. {    BYTE dst = regs.d[dstreg];
  2599. {    ULONG newv = dst - src;
  2600. {    bool flgs = ((BYTE)(src)) < 0;
  2601.     bool flgo = ((BYTE)(dst)) < 0;
  2602.     bool flgn = ((BYTE)(newv)) < 0;
  2603.     regs.z = ((BYTE)(newv)) == 0;
  2604.     regs.v = (flgs != flgo) && (flgn != flgo);
  2605.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2606.     regs.n = flgn != 0;
  2607. }}}}}}
  2608. void op_c10(UWORD opcode)
  2609. {
  2610.     ULONG dstreg = (opcode & 7) >> 0;
  2611. {{    BYTE src = nextiword();
  2612. {    CPTR dsta = regs.a[dstreg];
  2613.     BYTE dst = get_byte(dsta);
  2614. {    ULONG newv = dst - src;
  2615. {    bool flgs = ((BYTE)(src)) < 0;
  2616.     bool flgo = ((BYTE)(dst)) < 0;
  2617.     bool flgn = ((BYTE)(newv)) < 0;
  2618.     regs.z = ((BYTE)(newv)) == 0;
  2619.     regs.v = (flgs != flgo) && (flgn != flgo);
  2620.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2621.     regs.n = flgn != 0;
  2622. }}}}}}
  2623. void op_c18(UWORD opcode)
  2624. {
  2625.     ULONG dstreg = (opcode & 7) >> 0;
  2626. {{    BYTE src = nextiword();
  2627. {    CPTR dsta = regs.a[dstreg];
  2628.     BYTE dst = get_byte(dsta);
  2629. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  2630. {    ULONG newv = dst - src;
  2631. {    bool flgs = ((BYTE)(src)) < 0;
  2632.     bool flgo = ((BYTE)(dst)) < 0;
  2633.     bool flgn = ((BYTE)(newv)) < 0;
  2634.     regs.z = ((BYTE)(newv)) == 0;
  2635.     regs.v = (flgs != flgo) && (flgn != flgo);
  2636.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2637.     regs.n = flgn != 0;
  2638. }}}}}}}
  2639. void op_c20(UWORD opcode)
  2640. {
  2641.     ULONG dstreg = (opcode & 7) >> 0;
  2642. {{    BYTE src = nextiword();
  2643. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  2644. {    CPTR dsta = regs.a[dstreg];
  2645.     BYTE dst = get_byte(dsta);
  2646. {    ULONG newv = dst - src;
  2647. {    bool flgs = ((BYTE)(src)) < 0;
  2648.     bool flgo = ((BYTE)(dst)) < 0;
  2649.     bool flgn = ((BYTE)(newv)) < 0;
  2650.     regs.z = ((BYTE)(newv)) == 0;
  2651.     regs.v = (flgs != flgo) && (flgn != flgo);
  2652.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2653.     regs.n = flgn != 0;
  2654. }}}}}}}
  2655. void op_c28(UWORD opcode)
  2656. {
  2657.     ULONG dstreg = (opcode & 7) >> 0;
  2658. {{    BYTE src = nextiword();
  2659. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2660.     BYTE dst = get_byte(dsta);
  2661. {    ULONG newv = dst - src;
  2662. {    bool flgs = ((BYTE)(src)) < 0;
  2663.     bool flgo = ((BYTE)(dst)) < 0;
  2664.     bool flgn = ((BYTE)(newv)) < 0;
  2665.     regs.z = ((BYTE)(newv)) == 0;
  2666.     regs.v = (flgs != flgo) && (flgn != flgo);
  2667.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2668.     regs.n = flgn != 0;
  2669. }}}}}}
  2670. void op_c30(UWORD opcode)
  2671. {
  2672.     ULONG dstreg = (opcode & 7) >> 0;
  2673. {{    BYTE src = nextiword();
  2674. {    CPTR dsta = regs.a[dstreg];
  2675.     UWORD dstdp = nextiword();
  2676.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2677. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2678.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2679.     dsta += dstdpr;
  2680. {    BYTE dst = get_byte(dsta);
  2681. {    ULONG newv = dst - src;
  2682. {    bool flgs = ((BYTE)(src)) < 0;
  2683.     bool flgo = ((BYTE)(dst)) < 0;
  2684.     bool flgn = ((BYTE)(newv)) < 0;
  2685.     regs.z = ((BYTE)(newv)) == 0;
  2686.     regs.v = (flgs != flgo) && (flgn != flgo);
  2687.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2688.     regs.n = flgn != 0;
  2689. }}}}}}}}
  2690. void op_c38(UWORD opcode)
  2691. {
  2692. {{    BYTE src = nextiword();
  2693. {    CPTR dsta = (LONG)(WORD)nextiword();
  2694.     BYTE dst = get_byte(dsta);
  2695. {    ULONG newv = dst - src;
  2696. {    bool flgs = ((BYTE)(src)) < 0;
  2697.     bool flgo = ((BYTE)(dst)) < 0;
  2698.     bool flgn = ((BYTE)(newv)) < 0;
  2699.     regs.z = ((BYTE)(newv)) == 0;
  2700.     regs.v = (flgs != flgo) && (flgn != flgo);
  2701.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2702.     regs.n = flgn != 0;
  2703. }}}}}}
  2704. void op_c39(UWORD opcode)
  2705. {
  2706. {{    BYTE src = nextiword();
  2707. {    CPTR dsta = nextilong();
  2708.     BYTE dst = get_byte(dsta);
  2709. {    ULONG newv = dst - src;
  2710. {    bool flgs = ((BYTE)(src)) < 0;
  2711.     bool flgo = ((BYTE)(dst)) < 0;
  2712.     bool flgn = ((BYTE)(newv)) < 0;
  2713.     regs.z = ((BYTE)(newv)) == 0;
  2714.     regs.v = (flgs != flgo) && (flgn != flgo);
  2715.     regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
  2716.     regs.n = flgn != 0;
  2717. }}}}}}
  2718. void op_c40(UWORD opcode)
  2719. {
  2720.     ULONG dstreg = (opcode & 7) >> 0;
  2721. {{    WORD src = nextiword();
  2722. {    WORD dst = regs.d[dstreg];
  2723. {    ULONG newv = dst - src;
  2724. {    bool flgs = ((WORD)(src)) < 0;
  2725.     bool flgo = ((WORD)(dst)) < 0;
  2726.     bool flgn = ((WORD)(newv)) < 0;
  2727.     regs.z = ((WORD)(newv)) == 0;
  2728.     regs.v = (flgs != flgo) && (flgn != flgo);
  2729.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2730.     regs.n = flgn != 0;
  2731. }}}}}}
  2732. void op_c50(UWORD opcode)
  2733. {
  2734.     ULONG dstreg = (opcode & 7) >> 0;
  2735. {{    WORD src = nextiword();
  2736. {    CPTR dsta = regs.a[dstreg];
  2737.     WORD dst = get_word(dsta);
  2738. {    ULONG newv = dst - src;
  2739. {    bool flgs = ((WORD)(src)) < 0;
  2740.     bool flgo = ((WORD)(dst)) < 0;
  2741.     bool flgn = ((WORD)(newv)) < 0;
  2742.     regs.z = ((WORD)(newv)) == 0;
  2743.     regs.v = (flgs != flgo) && (flgn != flgo);
  2744.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2745.     regs.n = flgn != 0;
  2746. }}}}}}
  2747. void op_c58(UWORD opcode)
  2748. {
  2749.     ULONG dstreg = (opcode & 7) >> 0;
  2750. {{    WORD src = nextiword();
  2751. {    CPTR dsta = regs.a[dstreg];
  2752.     WORD dst = get_word(dsta);
  2753. {    regs.a[dstreg] += 2;
  2754. {    ULONG newv = dst - src;
  2755. {    bool flgs = ((WORD)(src)) < 0;
  2756.     bool flgo = ((WORD)(dst)) < 0;
  2757.     bool flgn = ((WORD)(newv)) < 0;
  2758.     regs.z = ((WORD)(newv)) == 0;
  2759.     regs.v = (flgs != flgo) && (flgn != flgo);
  2760.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2761.     regs.n = flgn != 0;
  2762. }}}}}}}
  2763. void op_c60(UWORD opcode)
  2764. {
  2765.     ULONG dstreg = (opcode & 7) >> 0;
  2766. {{    WORD src = nextiword();
  2767. {    regs.a[dstreg] -= 2;
  2768. {    CPTR dsta = regs.a[dstreg];
  2769.     WORD dst = get_word(dsta);
  2770. {    ULONG newv = dst - src;
  2771. {    bool flgs = ((WORD)(src)) < 0;
  2772.     bool flgo = ((WORD)(dst)) < 0;
  2773.     bool flgn = ((WORD)(newv)) < 0;
  2774.     regs.z = ((WORD)(newv)) == 0;
  2775.     regs.v = (flgs != flgo) && (flgn != flgo);
  2776.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2777.     regs.n = flgn != 0;
  2778. }}}}}}}
  2779. void op_c68(UWORD opcode)
  2780. {
  2781.     ULONG dstreg = (opcode & 7) >> 0;
  2782. {{    WORD src = nextiword();
  2783. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2784.     WORD dst = get_word(dsta);
  2785. {    ULONG newv = dst - src;
  2786. {    bool flgs = ((WORD)(src)) < 0;
  2787.     bool flgo = ((WORD)(dst)) < 0;
  2788.     bool flgn = ((WORD)(newv)) < 0;
  2789.     regs.z = ((WORD)(newv)) == 0;
  2790.     regs.v = (flgs != flgo) && (flgn != flgo);
  2791.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2792.     regs.n = flgn != 0;
  2793. }}}}}}
  2794. void op_c70(UWORD opcode)
  2795. {
  2796.     ULONG dstreg = (opcode & 7) >> 0;
  2797. {{    WORD src = nextiword();
  2798. {    CPTR dsta = regs.a[dstreg];
  2799.     UWORD dstdp = nextiword();
  2800.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2801. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2802.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2803.     dsta += dstdpr;
  2804. {    WORD dst = get_word(dsta);
  2805. {    ULONG newv = dst - src;
  2806. {    bool flgs = ((WORD)(src)) < 0;
  2807.     bool flgo = ((WORD)(dst)) < 0;
  2808.     bool flgn = ((WORD)(newv)) < 0;
  2809.     regs.z = ((WORD)(newv)) == 0;
  2810.     regs.v = (flgs != flgo) && (flgn != flgo);
  2811.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2812.     regs.n = flgn != 0;
  2813. }}}}}}}}
  2814. void op_c78(UWORD opcode)
  2815. {
  2816. {{    WORD src = nextiword();
  2817. {    CPTR dsta = (LONG)(WORD)nextiword();
  2818.     WORD dst = get_word(dsta);
  2819. {    ULONG newv = dst - src;
  2820. {    bool flgs = ((WORD)(src)) < 0;
  2821.     bool flgo = ((WORD)(dst)) < 0;
  2822.     bool flgn = ((WORD)(newv)) < 0;
  2823.     regs.z = ((WORD)(newv)) == 0;
  2824.     regs.v = (flgs != flgo) && (flgn != flgo);
  2825.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2826.     regs.n = flgn != 0;
  2827. }}}}}}
  2828. void op_c79(UWORD opcode)
  2829. {
  2830. {{    WORD src = nextiword();
  2831. {    CPTR dsta = nextilong();
  2832.     WORD dst = get_word(dsta);
  2833. {    ULONG newv = dst - src;
  2834. {    bool flgs = ((WORD)(src)) < 0;
  2835.     bool flgo = ((WORD)(dst)) < 0;
  2836.     bool flgn = ((WORD)(newv)) < 0;
  2837.     regs.z = ((WORD)(newv)) == 0;
  2838.     regs.v = (flgs != flgo) && (flgn != flgo);
  2839.     regs.c = ((UWORD)(src)) > ((UWORD)(dst));
  2840.     regs.n = flgn != 0;
  2841. }}}}}}
  2842. void op_c80(UWORD opcode)
  2843. {
  2844.     ULONG dstreg = (opcode & 7) >> 0;
  2845. {{    LONG src = nextilong();
  2846. {    LONG dst = regs.d[dstreg];
  2847. {    ULONG newv = dst - src;
  2848. {    bool flgs = ((LONG)(src)) < 0;
  2849.     bool flgo = ((LONG)(dst)) < 0;
  2850.     bool flgn = ((LONG)(newv)) < 0;
  2851.     regs.z = ((LONG)(newv)) == 0;
  2852.     regs.v = (flgs != flgo) && (flgn != flgo);
  2853.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2854.     regs.n = flgn != 0;
  2855. }}}}}}
  2856. void op_c90(UWORD opcode)
  2857. {
  2858.     ULONG dstreg = (opcode & 7) >> 0;
  2859. {{    LONG src = nextilong();
  2860. {    CPTR dsta = regs.a[dstreg];
  2861.     LONG dst = get_long(dsta);
  2862. {    ULONG newv = dst - src;
  2863. {    bool flgs = ((LONG)(src)) < 0;
  2864.     bool flgo = ((LONG)(dst)) < 0;
  2865.     bool flgn = ((LONG)(newv)) < 0;
  2866.     regs.z = ((LONG)(newv)) == 0;
  2867.     regs.v = (flgs != flgo) && (flgn != flgo);
  2868.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2869.     regs.n = flgn != 0;
  2870. }}}}}}
  2871. void op_c98(UWORD opcode)
  2872. {
  2873.     ULONG dstreg = (opcode & 7) >> 0;
  2874. {{    LONG src = nextilong();
  2875. {    CPTR dsta = regs.a[dstreg];
  2876.     LONG dst = get_long(dsta);
  2877. {    regs.a[dstreg] += 4;
  2878. {    ULONG newv = dst - src;
  2879. {    bool flgs = ((LONG)(src)) < 0;
  2880.     bool flgo = ((LONG)(dst)) < 0;
  2881.     bool flgn = ((LONG)(newv)) < 0;
  2882.     regs.z = ((LONG)(newv)) == 0;
  2883.     regs.v = (flgs != flgo) && (flgn != flgo);
  2884.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2885.     regs.n = flgn != 0;
  2886. }}}}}}}
  2887. void op_ca0(UWORD opcode)
  2888. {
  2889.     ULONG dstreg = (opcode & 7) >> 0;
  2890. {{    LONG src = nextilong();
  2891. {    regs.a[dstreg] -= 4;
  2892. {    CPTR dsta = regs.a[dstreg];
  2893.     LONG dst = get_long(dsta);
  2894. {    ULONG newv = dst - src;
  2895. {    bool flgs = ((LONG)(src)) < 0;
  2896.     bool flgo = ((LONG)(dst)) < 0;
  2897.     bool flgn = ((LONG)(newv)) < 0;
  2898.     regs.z = ((LONG)(newv)) == 0;
  2899.     regs.v = (flgs != flgo) && (flgn != flgo);
  2900.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2901.     regs.n = flgn != 0;
  2902. }}}}}}}
  2903. void op_ca8(UWORD opcode)
  2904. {
  2905.     ULONG dstreg = (opcode & 7) >> 0;
  2906. {{    LONG src = nextilong();
  2907. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  2908.     LONG dst = get_long(dsta);
  2909. {    ULONG newv = dst - src;
  2910. {    bool flgs = ((LONG)(src)) < 0;
  2911.     bool flgo = ((LONG)(dst)) < 0;
  2912.     bool flgn = ((LONG)(newv)) < 0;
  2913.     regs.z = ((LONG)(newv)) == 0;
  2914.     regs.v = (flgs != flgo) && (flgn != flgo);
  2915.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2916.     regs.n = flgn != 0;
  2917. }}}}}}
  2918. void op_cb0(UWORD opcode)
  2919. {
  2920.     ULONG dstreg = (opcode & 7) >> 0;
  2921. {{    LONG src = nextilong();
  2922. {    CPTR dsta = regs.a[dstreg];
  2923.     UWORD dstdp = nextiword();
  2924.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  2925. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  2926.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  2927.     dsta += dstdpr;
  2928. {    LONG dst = get_long(dsta);
  2929. {    ULONG newv = dst - src;
  2930. {    bool flgs = ((LONG)(src)) < 0;
  2931.     bool flgo = ((LONG)(dst)) < 0;
  2932.     bool flgn = ((LONG)(newv)) < 0;
  2933.     regs.z = ((LONG)(newv)) == 0;
  2934.     regs.v = (flgs != flgo) && (flgn != flgo);
  2935.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2936.     regs.n = flgn != 0;
  2937. }}}}}}}}
  2938. void op_cb8(UWORD opcode)
  2939. {
  2940. {{    LONG src = nextilong();
  2941. {    CPTR dsta = (LONG)(WORD)nextiword();
  2942.     LONG dst = get_long(dsta);
  2943. {    ULONG newv = dst - src;
  2944. {    bool flgs = ((LONG)(src)) < 0;
  2945.     bool flgo = ((LONG)(dst)) < 0;
  2946.     bool flgn = ((LONG)(newv)) < 0;
  2947.     regs.z = ((LONG)(newv)) == 0;
  2948.     regs.v = (flgs != flgo) && (flgn != flgo);
  2949.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2950.     regs.n = flgn != 0;
  2951. }}}}}}
  2952. void op_cb9(UWORD opcode)
  2953. {
  2954. {{    LONG src = nextilong();
  2955. {    CPTR dsta = nextilong();
  2956.     LONG dst = get_long(dsta);
  2957. {    ULONG newv = dst - src;
  2958. {    bool flgs = ((LONG)(src)) < 0;
  2959.     bool flgo = ((LONG)(dst)) < 0;
  2960.     bool flgn = ((LONG)(newv)) < 0;
  2961.     regs.z = ((LONG)(newv)) == 0;
  2962.     regs.v = (flgs != flgo) && (flgn != flgo);
  2963.     regs.c = ((ULONG)(src)) > ((ULONG)(dst));
  2964.     regs.n = flgn != 0;
  2965. }}}}}}
  2966.